Google Git
Sign in
android / platform / tools / gpu / 2c5fcf9c34c949b3471792de609aec0760e44eef / . / gapid / gfxapi / gles / mutate.go
blob: 66f5f1df168380493c165e74d2cac0c6c2109d79 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////
package gles
import (
"fmt"
"strings"
"android.googlesource.com/platform/tools/gpu/framework/log"
"android.googlesource.com/platform/tools/gpu/framework/stringtable/msg"
"android.googlesource.com/platform/tools/gpu/gapid/atom"
"android.googlesource.com/platform/tools/gpu/gapid/database"
"android.googlesource.com/platform/tools/gpu/gapid/gfxapi"
"android.googlesource.com/platform/tools/gpu/gapid/memory"
"android.googlesource.com/platform/tools/gpu/gapid/messages"
"android.googlesource.com/platform/tools/gpu/gapid/replay/builder"
"android.googlesource.com/platform/tools/gpu/gapid/replay/protocol"
"android.googlesource.com/platform/tools/gpu/gapid/replay/value"
)
type callable interface {
Call(log.Context, *gfxapi.State, database.Database, *builder.Builder)
}
// GetState returns the gles state from the gfxapi.State.
func GetState(s *gfxapi.State) *State {
api := API()
if state, ok := s.APIs[api].(*State); ok {
return state
} else {
state = &State{}
state.Init()
s.APIs[api] = state
return state
}
}
func loadRemap(ϟb *builder.Builder, key interface{}, ty protocol.Type, val value.Value) {
if ptr, found := ϟb.Remappings[key]; found {
ϟb.Load(ty, ptr)
} else {
ptr = ϟb.AllocateMemory(uint64(ty.Size(ϟb.Architecture().PointerSize)))
ϟb.Push(val) // We have an input to an unknown id, use the unmapped value.
ϟb.Clone(0)
ϟb.Store(ptr)
ϟb.Remappings[key] = ptr
}
}
var funcInfoGlBlendBarrierKHR = builder.FunctionInfo{ApiIndex: 1, ID: 0, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlBlendEquationSeparateiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 1, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBlendEquationiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 2, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendFuncSeparateiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 3, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlBlendFunciEXT = builder.FunctionInfo{ApiIndex: 1, ID: 4, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlColorMaskiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 5, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlCopyImageSubDataEXT = builder.FunctionInfo{ApiIndex: 1, ID: 6, ReturnType: protocol.Type_Void, Parameters: 15}
var funcInfoGlDebugMessageCallbackKHR = builder.FunctionInfo{ApiIndex: 1, ID: 7, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDebugMessageControlKHR = builder.FunctionInfo{ApiIndex: 1, ID: 8, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDebugMessageInsertKHR = builder.FunctionInfo{ApiIndex: 1, ID: 9, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDisableiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 10, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEnableiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 11, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFramebufferTextureEXT = builder.FunctionInfo{ApiIndex: 1, ID: 12, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetDebugMessageLogKHR = builder.FunctionInfo{ApiIndex: 1, ID: 13, ReturnType: protocol.Type_Uint32, Parameters: 8}
var funcInfoGlGetObjectLabelKHR = builder.FunctionInfo{ApiIndex: 1, ID: 14, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetObjectPtrLabelKHR = builder.FunctionInfo{ApiIndex: 1, ID: 15, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetPointervKHR = builder.FunctionInfo{ApiIndex: 1, ID: 16, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetSamplerParameterIivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 17, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameterIuivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 18, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterIivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 19, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterIuivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 20, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsEnablediEXT = builder.FunctionInfo{ApiIndex: 1, ID: 21, ReturnType: protocol.Type_Uint8, Parameters: 2}
var funcInfoGlMinSampleShadingOES = builder.FunctionInfo{ApiIndex: 1, ID: 22, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlObjectLabelKHR = builder.FunctionInfo{ApiIndex: 1, ID: 23, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlObjectPtrLabelKHR = builder.FunctionInfo{ApiIndex: 1, ID: 24, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPatchParameteriEXT = builder.FunctionInfo{ApiIndex: 1, ID: 25, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPopDebugGroupKHR = builder.FunctionInfo{ApiIndex: 1, ID: 26, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlPrimitiveBoundingBoxEXT = builder.FunctionInfo{ApiIndex: 1, ID: 27, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlPushDebugGroupKHR = builder.FunctionInfo{ApiIndex: 1, ID: 28, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlSamplerParameterIivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 29, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameterIuivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 30, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexBufferEXT = builder.FunctionInfo{ApiIndex: 1, ID: 31, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexBufferRangeEXT = builder.FunctionInfo{ApiIndex: 1, ID: 32, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTexParameterIivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 33, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterIuivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 34, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexStorage3DMultisampleOES = builder.FunctionInfo{ApiIndex: 1, ID: 35, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlBeginQuery = builder.FunctionInfo{ApiIndex: 1, ID: 36, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteQueries = builder.FunctionInfo{ApiIndex: 1, ID: 37, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEndQuery = builder.FunctionInfo{ApiIndex: 1, ID: 38, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGenQueries = builder.FunctionInfo{ApiIndex: 1, ID: 39, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetQueryObjectuiv = builder.FunctionInfo{ApiIndex: 1, ID: 40, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryiv = builder.FunctionInfo{ApiIndex: 1, ID: 41, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsQuery = builder.FunctionInfo{ApiIndex: 1, ID: 42, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlBindBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 43, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindBufferBase = builder.FunctionInfo{ApiIndex: 1, ID: 44, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBindBufferRange = builder.FunctionInfo{ApiIndex: 1, ID: 45, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlBufferData = builder.FunctionInfo{ApiIndex: 1, ID: 46, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBufferSubData = builder.FunctionInfo{ApiIndex: 1, ID: 47, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlCopyBufferSubData = builder.FunctionInfo{ApiIndex: 1, ID: 48, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDeleteBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 49, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 50, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetBufferParameteri64v = builder.FunctionInfo{ApiIndex: 1, ID: 51, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetBufferParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 52, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetBufferPointerv = builder.FunctionInfo{ApiIndex: 1, ID: 53, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 54, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlMapBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 55, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoGlMapBufferRange = builder.FunctionInfo{ApiIndex: 1, ID: 56, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoGlUnmapBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 57, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlFlushMappedBufferRange = builder.FunctionInfo{ApiIndex: 1, ID: 58, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDebugMessageCallback = builder.FunctionInfo{ApiIndex: 1, ID: 59, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDebugMessageControl = builder.FunctionInfo{ApiIndex: 1, ID: 60, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDebugMessageInsert = builder.FunctionInfo{ApiIndex: 1, ID: 61, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlGetDebugMessageLog = builder.FunctionInfo{ApiIndex: 1, ID: 62, ReturnType: protocol.Type_Uint32, Parameters: 8}
var funcInfoGlGetObjectLabel = builder.FunctionInfo{ApiIndex: 1, ID: 63, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetObjectPtrLabel = builder.FunctionInfo{ApiIndex: 1, ID: 64, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetPointerv = builder.FunctionInfo{ApiIndex: 1, ID: 65, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlObjectLabel = builder.FunctionInfo{ApiIndex: 1, ID: 66, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlObjectPtrLabel = builder.FunctionInfo{ApiIndex: 1, ID: 67, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPopDebugGroup = builder.FunctionInfo{ApiIndex: 1, ID: 68, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlPushDebugGroup = builder.FunctionInfo{ApiIndex: 1, ID: 69, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawArrays = builder.FunctionInfo{ApiIndex: 1, ID: 70, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDrawArraysIndirect = builder.FunctionInfo{ApiIndex: 1, ID: 71, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDrawArraysInstanced = builder.FunctionInfo{ApiIndex: 1, ID: 72, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawElements = builder.FunctionInfo{ApiIndex: 1, ID: 73, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawElementsBaseVertex = builder.FunctionInfo{ApiIndex: 1, ID: 74, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsIndirect = builder.FunctionInfo{ApiIndex: 1, ID: 75, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDrawElementsInstanced = builder.FunctionInfo{ApiIndex: 1, ID: 76, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsInstancedBaseVertex = builder.FunctionInfo{ApiIndex: 1, ID: 77, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDrawRangeElements = builder.FunctionInfo{ApiIndex: 1, ID: 78, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDrawRangeElementsBaseVertex = builder.FunctionInfo{ApiIndex: 1, ID: 79, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlPatchParameteri = builder.FunctionInfo{ApiIndex: 1, ID: 80, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPrimitiveBoundingBox = builder.FunctionInfo{ApiIndex: 1, ID: 81, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoEglGetConfigAttrib = builder.FunctionInfo{ApiIndex: 1, ID: 82, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglBindAPI = builder.FunctionInfo{ApiIndex: 1, ID: 83, ReturnType: protocol.Type_Int64, Parameters: 1}
var funcInfoEglBindTexImage = builder.FunctionInfo{ApiIndex: 1, ID: 84, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoEglChooseConfig = builder.FunctionInfo{ApiIndex: 1, ID: 85, ReturnType: protocol.Type_Int64, Parameters: 5}
var funcInfoEglClientWaitSyncKHR = builder.FunctionInfo{ApiIndex: 1, ID: 86, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglCopyBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 87, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoEglCreateContext = builder.FunctionInfo{ApiIndex: 1, ID: 88, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoEglCreatePbufferFromClientBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 89, ReturnType: protocol.Type_AbsolutePointer, Parameters: 5}
var funcInfoEglCreatePbufferSurface = builder.FunctionInfo{ApiIndex: 1, ID: 90, ReturnType: protocol.Type_AbsolutePointer, Parameters: 3}
var funcInfoEglCreatePixmapSurface = builder.FunctionInfo{ApiIndex: 1, ID: 91, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoEglCreateSyncKHR = builder.FunctionInfo{ApiIndex: 1, ID: 92, ReturnType: protocol.Type_AbsolutePointer, Parameters: 3}
var funcInfoEglCreateWindowSurface = builder.FunctionInfo{ApiIndex: 1, ID: 93, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoEglDestroyContext = builder.FunctionInfo{ApiIndex: 1, ID: 94, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglDestroySurface = builder.FunctionInfo{ApiIndex: 1, ID: 95, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglDestroySyncKHR = builder.FunctionInfo{ApiIndex: 1, ID: 96, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglGetConfigs = builder.FunctionInfo{ApiIndex: 1, ID: 97, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglGetCurrentContext = builder.FunctionInfo{ApiIndex: 1, ID: 98, ReturnType: protocol.Type_AbsolutePointer, Parameters: 0}
var funcInfoEglGetCurrentDisplay = builder.FunctionInfo{ApiIndex: 1, ID: 99, ReturnType: protocol.Type_AbsolutePointer, Parameters: 0}
var funcInfoEglGetCurrentSurface = builder.FunctionInfo{ApiIndex: 1, ID: 100, ReturnType: protocol.Type_AbsolutePointer, Parameters: 1}
var funcInfoEglGetDisplay = builder.FunctionInfo{ApiIndex: 1, ID: 101, ReturnType: protocol.Type_AbsolutePointer, Parameters: 1}
var funcInfoEglGetError = builder.FunctionInfo{ApiIndex: 1, ID: 102, ReturnType: protocol.Type_Int64, Parameters: 0}
var funcInfoEglGetSyncAttribKHR = builder.FunctionInfo{ApiIndex: 1, ID: 103, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglInitialize = builder.FunctionInfo{ApiIndex: 1, ID: 104, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoEglMakeCurrent = builder.FunctionInfo{ApiIndex: 1, ID: 105, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglQueryAPI = builder.FunctionInfo{ApiIndex: 1, ID: 106, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoEglQueryContext = builder.FunctionInfo{ApiIndex: 1, ID: 107, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglQuerySurface = builder.FunctionInfo{ApiIndex: 1, ID: 108, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglQueryString = builder.FunctionInfo{ApiIndex: 1, ID: 109, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoEglReleaseTexImage = builder.FunctionInfo{ApiIndex: 1, ID: 110, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoEglReleaseThread = builder.FunctionInfo{ApiIndex: 1, ID: 111, ReturnType: protocol.Type_Int64, Parameters: 0}
var funcInfoEglSignalSyncKHR = builder.FunctionInfo{ApiIndex: 1, ID: 112, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoEglSurfaceAttrib = builder.FunctionInfo{ApiIndex: 1, ID: 113, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglSwapBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 114, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglSwapBuffersWithDamageKHR = builder.FunctionInfo{ApiIndex: 1, ID: 115, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoEglSwapInterval = builder.FunctionInfo{ApiIndex: 1, ID: 116, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglTerminate = builder.FunctionInfo{ApiIndex: 1, ID: 117, ReturnType: protocol.Type_Int64, Parameters: 1}
var funcInfoEglWaitClient = builder.FunctionInfo{ApiIndex: 1, ID: 118, ReturnType: protocol.Type_Int64, Parameters: 0}
var funcInfoEglWaitGL = builder.FunctionInfo{ApiIndex: 1, ID: 119, ReturnType: protocol.Type_Int64, Parameters: 0}
var funcInfoEglWaitNative = builder.FunctionInfo{ApiIndex: 1, ID: 120, ReturnType: protocol.Type_Int64, Parameters: 1}
var funcInfoEglCreateImageKHR = builder.FunctionInfo{ApiIndex: 1, ID: 121, ReturnType: protocol.Type_AbsolutePointer, Parameters: 5}
var funcInfoEglDestroyImageKHR = builder.FunctionInfo{ApiIndex: 1, ID: 122, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoEglCreateNativeClientBufferANDROID = builder.FunctionInfo{ApiIndex: 1, ID: 123, ReturnType: protocol.Type_AbsolutePointer, Parameters: 1}
var funcInfoGlActiveShaderProgramEXT = builder.FunctionInfo{ApiIndex: 1, ID: 124, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlAlphaFuncQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 125, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlApplyFramebufferAttachmentCMAAINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 126, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlBeginConditionalRenderNV = builder.FunctionInfo{ApiIndex: 1, ID: 127, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBeginPerfMonitorAMD = builder.FunctionInfo{ApiIndex: 1, ID: 128, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBeginPerfQueryINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 129, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBeginQueryEXT = builder.FunctionInfo{ApiIndex: 1, ID: 130, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindFragDataLocationEXT = builder.FunctionInfo{ApiIndex: 1, ID: 131, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBindFragDataLocationIndexedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 132, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBindProgramPipelineEXT = builder.FunctionInfo{ApiIndex: 1, ID: 133, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBindVertexArrayOES = builder.FunctionInfo{ApiIndex: 1, ID: 134, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBlendBarrierNV = builder.FunctionInfo{ApiIndex: 1, ID: 135, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlBlendEquationSeparateiOES = builder.FunctionInfo{ApiIndex: 1, ID: 136, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBlendEquationiOES = builder.FunctionInfo{ApiIndex: 1, ID: 137, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendFuncSeparateiOES = builder.FunctionInfo{ApiIndex: 1, ID: 138, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlBlendFunciOES = builder.FunctionInfo{ApiIndex: 1, ID: 139, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBlendParameteriNV = builder.FunctionInfo{ApiIndex: 1, ID: 140, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlitFramebufferANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 141, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlBlitFramebufferNV = builder.FunctionInfo{ApiIndex: 1, ID: 142, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlBufferStorageEXT = builder.FunctionInfo{ApiIndex: 1, ID: 143, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClientWaitSyncAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 144, ReturnType: protocol.Type_Uint32, Parameters: 3}
var funcInfoGlColorMaskiOES = builder.FunctionInfo{ApiIndex: 1, ID: 145, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlCompressedTexImage3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 146, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlCompressedTexSubImage3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 147, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlCopyBufferSubDataNV = builder.FunctionInfo{ApiIndex: 1, ID: 148, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlCopyImageSubDataOES = builder.FunctionInfo{ApiIndex: 1, ID: 149, ReturnType: protocol.Type_Void, Parameters: 15}
var funcInfoGlCopyPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 150, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCopyTexSubImage3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 151, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlCopyTextureLevelsAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 152, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlCoverFillPathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 153, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlCoverFillPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 154, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCoverStrokePathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 155, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlCoverStrokePathNV = builder.FunctionInfo{ApiIndex: 1, ID: 156, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCoverageMaskNV = builder.FunctionInfo{ApiIndex: 1, ID: 157, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCoverageModulationNV = builder.FunctionInfo{ApiIndex: 1, ID: 158, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCoverageModulationTableNV = builder.FunctionInfo{ApiIndex: 1, ID: 159, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCoverageOperationNV = builder.FunctionInfo{ApiIndex: 1, ID: 160, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCreatePerfQueryINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 161, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCreateShaderProgramvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 162, ReturnType: protocol.Type_Uint32, Parameters: 3}
var funcInfoGlDeleteFencesNV = builder.FunctionInfo{ApiIndex: 1, ID: 163, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeletePathsNV = builder.FunctionInfo{ApiIndex: 1, ID: 164, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeletePerfMonitorsAMD = builder.FunctionInfo{ApiIndex: 1, ID: 165, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeletePerfQueryINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 166, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDeleteProgramPipelinesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 167, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteQueriesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 168, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteSyncAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 169, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDeleteVertexArraysOES = builder.FunctionInfo{ApiIndex: 1, ID: 170, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthRangeArrayfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 171, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDepthRangeIndexedfNV = builder.FunctionInfo{ApiIndex: 1, ID: 172, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDisableDriverControlQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 173, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDisableiNV = builder.FunctionInfo{ApiIndex: 1, ID: 174, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDisableiOES = builder.FunctionInfo{ApiIndex: 1, ID: 175, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDiscardFramebufferEXT = builder.FunctionInfo{ApiIndex: 1, ID: 176, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDrawArraysInstancedANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 177, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawArraysInstancedBaseInstanceEXT = builder.FunctionInfo{ApiIndex: 1, ID: 178, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawArraysInstancedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 179, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawArraysInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 180, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDrawBuffersEXT = builder.FunctionInfo{ApiIndex: 1, ID: 181, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDrawBuffersIndexedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 182, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDrawBuffersNV = builder.FunctionInfo{ApiIndex: 1, ID: 183, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDrawElementsBaseVertexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 184, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsBaseVertexOES = builder.FunctionInfo{ApiIndex: 1, ID: 185, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsInstancedANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 186, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsInstancedBaseInstanceEXT = builder.FunctionInfo{ApiIndex: 1, ID: 187, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDrawElementsInstancedBaseVertexBaseInstanceEXT = builder.FunctionInfo{ApiIndex: 1, ID: 188, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlDrawElementsInstancedBaseVertexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 189, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDrawElementsInstancedBaseVertexOES = builder.FunctionInfo{ApiIndex: 1, ID: 190, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlDrawElementsInstancedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 191, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawElementsInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 192, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawRangeElementsBaseVertexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 193, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlDrawRangeElementsBaseVertexOES = builder.FunctionInfo{ApiIndex: 1, ID: 194, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlEGLImageTargetRenderbufferStorageOES = builder.FunctionInfo{ApiIndex: 1, ID: 195, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEGLImageTargetTexture2DOES = builder.FunctionInfo{ApiIndex: 1, ID: 196, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEnableDriverControlQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 197, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEnableiNV = builder.FunctionInfo{ApiIndex: 1, ID: 198, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEnableiOES = builder.FunctionInfo{ApiIndex: 1, ID: 199, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEndConditionalRenderNV = builder.FunctionInfo{ApiIndex: 1, ID: 200, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlEndPerfMonitorAMD = builder.FunctionInfo{ApiIndex: 1, ID: 201, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEndPerfQueryINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 202, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEndQueryEXT = builder.FunctionInfo{ApiIndex: 1, ID: 203, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEndTilingQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 204, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlExtGetBufferPointervQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 205, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlExtGetBuffersQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 206, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtGetFramebuffersQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 207, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtGetProgramBinarySourceQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 208, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlExtGetProgramsQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 209, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtGetRenderbuffersQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 210, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtGetShadersQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 211, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtGetTexLevelParameterivQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 212, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlExtGetTexSubImageQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 213, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlExtGetTexturesQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 214, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlExtIsProgramBinaryQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 215, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlExtTexObjectStateOverrideiQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 216, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlFenceSyncAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 217, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoGlFinishFenceNV = builder.FunctionInfo{ApiIndex: 1, ID: 218, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlFlushMappedBufferRangeEXT = builder.FunctionInfo{ApiIndex: 1, ID: 219, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlFragmentCoverageColorNV = builder.FunctionInfo{ApiIndex: 1, ID: 220, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlFramebufferSampleLocationsfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 221, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlFramebufferTexture2DMultisampleEXT = builder.FunctionInfo{ApiIndex: 1, ID: 222, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFramebufferTexture2DMultisampleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 223, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFramebufferTexture3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 224, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFramebufferTextureMultiviewOVR = builder.FunctionInfo{ApiIndex: 1, ID: 225, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFramebufferTextureOES = builder.FunctionInfo{ApiIndex: 1, ID: 226, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGenFencesNV = builder.FunctionInfo{ApiIndex: 1, ID: 227, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenPathsNV = builder.FunctionInfo{ApiIndex: 1, ID: 228, ReturnType: protocol.Type_Uint32, Parameters: 1}
var funcInfoGlGenPerfMonitorsAMD = builder.FunctionInfo{ApiIndex: 1, ID: 229, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenProgramPipelinesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 230, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenQueriesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 231, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenVertexArraysOES = builder.FunctionInfo{ApiIndex: 1, ID: 232, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetBufferPointervOES = builder.FunctionInfo{ApiIndex: 1, ID: 233, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetCoverageModulationTableNV = builder.FunctionInfo{ApiIndex: 1, ID: 234, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetDriverControlStringQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 235, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetDriverControlsQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 236, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetFenceivNV = builder.FunctionInfo{ApiIndex: 1, ID: 237, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetFirstPerfQueryIdINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 238, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGetFloati_vNV = builder.FunctionInfo{ApiIndex: 1, ID: 239, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetFragDataIndexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 240, ReturnType: protocol.Type_Int32, Parameters: 2}
var funcInfoGlGetGraphicsResetStatusEXT = builder.FunctionInfo{ApiIndex: 1, ID: 241, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoGlGetGraphicsResetStatusKHR = builder.FunctionInfo{ApiIndex: 1, ID: 242, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoGlGetImageHandleNV = builder.FunctionInfo{ApiIndex: 1, ID: 243, ReturnType: protocol.Type_Uint64, Parameters: 5}
var funcInfoGlGetInteger64vAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 244, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetIntegeri_vEXT = builder.FunctionInfo{ApiIndex: 1, ID: 245, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetInternalformatSampleivNV = builder.FunctionInfo{ApiIndex: 1, ID: 246, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlGetNextPerfQueryIdINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 247, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetObjectLabelEXT = builder.FunctionInfo{ApiIndex: 1, ID: 248, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPathCommandsNV = builder.FunctionInfo{ApiIndex: 1, ID: 249, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetPathCoordsNV = builder.FunctionInfo{ApiIndex: 1, ID: 250, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetPathDashArrayNV = builder.FunctionInfo{ApiIndex: 1, ID: 251, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetPathLengthNV = builder.FunctionInfo{ApiIndex: 1, ID: 252, ReturnType: protocol.Type_Float, Parameters: 3}
var funcInfoGlGetPathMetricRangeNV = builder.FunctionInfo{ApiIndex: 1, ID: 253, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPathMetricsNV = builder.FunctionInfo{ApiIndex: 1, ID: 254, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlGetPathParameterfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 255, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetPathParameterivNV = builder.FunctionInfo{ApiIndex: 1, ID: 256, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetPathSpacingNV = builder.FunctionInfo{ApiIndex: 1, ID: 257, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlGetPerfCounterInfoINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 258, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlGetPerfMonitorCounterDataAMD = builder.FunctionInfo{ApiIndex: 1, ID: 259, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPerfMonitorCounterInfoAMD = builder.FunctionInfo{ApiIndex: 1, ID: 260, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetPerfMonitorCounterStringAMD = builder.FunctionInfo{ApiIndex: 1, ID: 261, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPerfMonitorCountersAMD = builder.FunctionInfo{ApiIndex: 1, ID: 262, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPerfMonitorGroupStringAMD = builder.FunctionInfo{ApiIndex: 1, ID: 263, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetPerfMonitorGroupsAMD = builder.FunctionInfo{ApiIndex: 1, ID: 264, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetPerfQueryDataINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 265, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetPerfQueryIdByNameINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 266, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetPerfQueryInfoINTEL = builder.FunctionInfo{ApiIndex: 1, ID: 267, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlGetProgramBinaryOES = builder.FunctionInfo{ApiIndex: 1, ID: 268, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetProgramPipelineInfoLogEXT = builder.FunctionInfo{ApiIndex: 1, ID: 269, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetProgramPipelineivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 270, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetProgramResourceLocationIndexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 271, ReturnType: protocol.Type_Int32, Parameters: 3}
var funcInfoGlGetProgramResourcefvNV = builder.FunctionInfo{ApiIndex: 1, ID: 272, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlGetQueryObjecti64vEXT = builder.FunctionInfo{ApiIndex: 1, ID: 273, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryObjectivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 274, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryObjectui64vEXT = builder.FunctionInfo{ApiIndex: 1, ID: 275, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryObjectuivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 276, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 277, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameterIivOES = builder.FunctionInfo{ApiIndex: 1, ID: 278, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameterIuivOES = builder.FunctionInfo{ApiIndex: 1, ID: 279, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSyncivAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 280, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetTexParameterIivOES = builder.FunctionInfo{ApiIndex: 1, ID: 281, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterIuivOES = builder.FunctionInfo{ApiIndex: 1, ID: 282, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTextureHandleNV = builder.FunctionInfo{ApiIndex: 1, ID: 283, ReturnType: protocol.Type_Uint64, Parameters: 1}
var funcInfoGlGetTextureSamplerHandleNV = builder.FunctionInfo{ApiIndex: 1, ID: 284, ReturnType: protocol.Type_Uint64, Parameters: 2}
var funcInfoGlGetTranslatedShaderSourceANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 285, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformfvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 286, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformfvKHR = builder.FunctionInfo{ApiIndex: 1, ID: 287, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 288, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformivKHR = builder.FunctionInfo{ApiIndex: 1, ID: 289, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformuivKHR = builder.FunctionInfo{ApiIndex: 1, ID: 290, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlInsertEventMarkerEXT = builder.FunctionInfo{ApiIndex: 1, ID: 291, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlInterpolatePathsNV = builder.FunctionInfo{ApiIndex: 1, ID: 292, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlIsEnablediNV = builder.FunctionInfo{ApiIndex: 1, ID: 293, ReturnType: protocol.Type_Uint8, Parameters: 2}
var funcInfoGlIsEnablediOES = builder.FunctionInfo{ApiIndex: 1, ID: 294, ReturnType: protocol.Type_Uint8, Parameters: 2}
var funcInfoGlIsFenceNV = builder.FunctionInfo{ApiIndex: 1, ID: 295, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsImageHandleResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 296, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 297, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsPointInFillPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 298, ReturnType: protocol.Type_Uint8, Parameters: 4}
var funcInfoGlIsPointInStrokePathNV = builder.FunctionInfo{ApiIndex: 1, ID: 299, ReturnType: protocol.Type_Uint8, Parameters: 3}
var funcInfoGlIsProgramPipelineEXT = builder.FunctionInfo{ApiIndex: 1, ID: 300, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsQueryEXT = builder.FunctionInfo{ApiIndex: 1, ID: 301, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsSyncAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 302, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsTextureHandleResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 303, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsVertexArrayOES = builder.FunctionInfo{ApiIndex: 1, ID: 304, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlLabelObjectEXT = builder.FunctionInfo{ApiIndex: 1, ID: 305, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlMakeImageHandleNonResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 306, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMakeImageHandleResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 307, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMakeTextureHandleNonResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 308, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMakeTextureHandleResidentNV = builder.FunctionInfo{ApiIndex: 1, ID: 309, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMapBufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 310, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoGlMapBufferRangeEXT = builder.FunctionInfo{ApiIndex: 1, ID: 311, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoGlMatrixLoad3x2fNV = builder.FunctionInfo{ApiIndex: 1, ID: 312, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMatrixLoad3x3fNV = builder.FunctionInfo{ApiIndex: 1, ID: 313, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMatrixLoadTranspose3x3fNV = builder.FunctionInfo{ApiIndex: 1, ID: 314, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMatrixMult3x2fNV = builder.FunctionInfo{ApiIndex: 1, ID: 315, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMatrixMult3x3fNV = builder.FunctionInfo{ApiIndex: 1, ID: 316, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMatrixMultTranspose3x3fNV = builder.FunctionInfo{ApiIndex: 1, ID: 317, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlMultiDrawArraysEXT = builder.FunctionInfo{ApiIndex: 1, ID: 318, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlMultiDrawArraysIndirectEXT = builder.FunctionInfo{ApiIndex: 1, ID: 319, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlMultiDrawElementsBaseVertexEXT = builder.FunctionInfo{ApiIndex: 1, ID: 320, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlMultiDrawElementsBaseVertexOES = builder.FunctionInfo{ApiIndex: 1, ID: 321, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlMultiDrawElementsEXT = builder.FunctionInfo{ApiIndex: 1, ID: 322, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlMultiDrawElementsIndirectEXT = builder.FunctionInfo{ApiIndex: 1, ID: 323, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlNamedFramebufferSampleLocationsfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 324, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlPatchParameteriOES = builder.FunctionInfo{ApiIndex: 1, ID: 325, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPathCommandsNV = builder.FunctionInfo{ApiIndex: 1, ID: 326, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlPathCoordsNV = builder.FunctionInfo{ApiIndex: 1, ID: 327, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlPathCoverDepthFuncNV = builder.FunctionInfo{ApiIndex: 1, ID: 328, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlPathDashArrayNV = builder.FunctionInfo{ApiIndex: 1, ID: 329, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathGlyphIndexArrayNV = builder.FunctionInfo{ApiIndex: 1, ID: 330, ReturnType: protocol.Type_Uint32, Parameters: 8}
var funcInfoGlPathGlyphIndexRangeNV = builder.FunctionInfo{ApiIndex: 1, ID: 331, ReturnType: protocol.Type_Uint32, Parameters: 6}
var funcInfoGlPathGlyphRangeNV = builder.FunctionInfo{ApiIndex: 1, ID: 332, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlPathGlyphsNV = builder.FunctionInfo{ApiIndex: 1, ID: 333, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlPathMemoryGlyphIndexArrayNV = builder.FunctionInfo{ApiIndex: 1, ID: 334, ReturnType: protocol.Type_Uint32, Parameters: 9}
var funcInfoGlPathParameterfNV = builder.FunctionInfo{ApiIndex: 1, ID: 335, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathParameterfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 336, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathParameteriNV = builder.FunctionInfo{ApiIndex: 1, ID: 337, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathParameterivNV = builder.FunctionInfo{ApiIndex: 1, ID: 338, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathStencilDepthOffsetNV = builder.FunctionInfo{ApiIndex: 1, ID: 339, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPathStencilFuncNV = builder.FunctionInfo{ApiIndex: 1, ID: 340, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPathStringNV = builder.FunctionInfo{ApiIndex: 1, ID: 341, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlPathSubCommandsNV = builder.FunctionInfo{ApiIndex: 1, ID: 342, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlPathSubCoordsNV = builder.FunctionInfo{ApiIndex: 1, ID: 343, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlPointAlongPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 344, ReturnType: protocol.Type_Uint8, Parameters: 8}
var funcInfoGlPolygonModeNV = builder.FunctionInfo{ApiIndex: 1, ID: 345, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPopGroupMarkerEXT = builder.FunctionInfo{ApiIndex: 1, ID: 346, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlPrimitiveBoundingBoxOES = builder.FunctionInfo{ApiIndex: 1, ID: 347, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlProgramBinaryOES = builder.FunctionInfo{ApiIndex: 1, ID: 348, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramParameteriEXT = builder.FunctionInfo{ApiIndex: 1, ID: 349, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramPathFragmentInputGenNV = builder.FunctionInfo{ApiIndex: 1, ID: 350, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform1fEXT = builder.FunctionInfo{ApiIndex: 1, ID: 351, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 352, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform1iEXT = builder.FunctionInfo{ApiIndex: 1, ID: 353, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1ivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 354, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform1uiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 355, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1uivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 356, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2fEXT = builder.FunctionInfo{ApiIndex: 1, ID: 357, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 358, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2iEXT = builder.FunctionInfo{ApiIndex: 1, ID: 359, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2ivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 360, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2uiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 361, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2uivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 362, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3fEXT = builder.FunctionInfo{ApiIndex: 1, ID: 363, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 364, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3iEXT = builder.FunctionInfo{ApiIndex: 1, ID: 365, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3ivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 366, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3uiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 367, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3uivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 368, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4fEXT = builder.FunctionInfo{ApiIndex: 1, ID: 369, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 370, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4iEXT = builder.FunctionInfo{ApiIndex: 1, ID: 371, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4ivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 372, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4uiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 373, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4uivEXT = builder.FunctionInfo{ApiIndex: 1, ID: 374, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniformHandleui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 375, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniformHandleui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 376, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniformMatrix2fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 377, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix2x3fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 378, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix2x4fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 379, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 380, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3x2fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 381, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3x4fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 382, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 383, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4x2fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 384, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4x3fvEXT = builder.FunctionInfo{ApiIndex: 1, ID: 385, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlPushGroupMarkerEXT = builder.FunctionInfo{ApiIndex: 1, ID: 386, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlQueryCounterEXT = builder.FunctionInfo{ApiIndex: 1, ID: 387, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlRasterSamplesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 388, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlReadBufferIndexedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 389, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlReadBufferNV = builder.FunctionInfo{ApiIndex: 1, ID: 390, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlReadnPixelsEXT = builder.FunctionInfo{ApiIndex: 1, ID: 391, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlReadnPixelsKHR = builder.FunctionInfo{ApiIndex: 1, ID: 392, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlRenderbufferStorageMultisampleANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 393, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlRenderbufferStorageMultisampleAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 394, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlRenderbufferStorageMultisampleEXT = builder.FunctionInfo{ApiIndex: 1, ID: 395, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlRenderbufferStorageMultisampleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 396, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlRenderbufferStorageMultisampleNV = builder.FunctionInfo{ApiIndex: 1, ID: 397, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlResolveDepthValuesNV = builder.FunctionInfo{ApiIndex: 1, ID: 398, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlResolveMultisampleFramebufferAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 399, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlSamplerParameterIivOES = builder.FunctionInfo{ApiIndex: 1, ID: 400, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameterIuivOES = builder.FunctionInfo{ApiIndex: 1, ID: 401, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlScissorArrayvNV = builder.FunctionInfo{ApiIndex: 1, ID: 402, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlScissorIndexedNV = builder.FunctionInfo{ApiIndex: 1, ID: 403, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlScissorIndexedvNV = builder.FunctionInfo{ApiIndex: 1, ID: 404, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlSelectPerfMonitorCountersAMD = builder.FunctionInfo{ApiIndex: 1, ID: 405, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlSetFenceNV = builder.FunctionInfo{ApiIndex: 1, ID: 406, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlStartTilingQCOM = builder.FunctionInfo{ApiIndex: 1, ID: 407, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlStencilFillPathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 408, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlStencilFillPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 409, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlStencilStrokePathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 410, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlStencilStrokePathNV = builder.FunctionInfo{ApiIndex: 1, ID: 411, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlStencilThenCoverFillPathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 412, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlStencilThenCoverFillPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 413, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlStencilThenCoverStrokePathInstancedNV = builder.FunctionInfo{ApiIndex: 1, ID: 414, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlStencilThenCoverStrokePathNV = builder.FunctionInfo{ApiIndex: 1, ID: 415, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlSubpixelPrecisionBiasNV = builder.FunctionInfo{ApiIndex: 1, ID: 416, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlTestFenceNV = builder.FunctionInfo{ApiIndex: 1, ID: 417, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlTexBufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 418, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexBufferRangeOES = builder.FunctionInfo{ApiIndex: 1, ID: 419, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTexImage3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 420, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlTexPageCommitmentEXT = builder.FunctionInfo{ApiIndex: 1, ID: 421, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlTexParameterIivOES = builder.FunctionInfo{ApiIndex: 1, ID: 422, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterIuivOES = builder.FunctionInfo{ApiIndex: 1, ID: 423, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexStorage1DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 424, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlTexStorage2DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 425, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTexStorage3DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 426, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlTexSubImage3DOES = builder.FunctionInfo{ApiIndex: 1, ID: 427, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlTextureStorage1DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 428, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTextureStorage2DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 429, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlTextureStorage3DEXT = builder.FunctionInfo{ApiIndex: 1, ID: 430, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlTextureViewEXT = builder.FunctionInfo{ApiIndex: 1, ID: 431, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlTextureViewOES = builder.FunctionInfo{ApiIndex: 1, ID: 432, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlTransformPathNV = builder.FunctionInfo{ApiIndex: 1, ID: 433, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformHandleui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 434, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniformHandleui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 435, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniformMatrix2x3fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 436, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix2x4fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 437, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix3x2fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 438, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix3x4fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 439, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix4x2fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 440, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix4x3fvNV = builder.FunctionInfo{ApiIndex: 1, ID: 441, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUnmapBufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 442, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlUseProgramStagesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 443, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlValidateProgramPipelineEXT = builder.FunctionInfo{ApiIndex: 1, ID: 444, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlVertexAttribDivisorANGLE = builder.FunctionInfo{ApiIndex: 1, ID: 445, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribDivisorEXT = builder.FunctionInfo{ApiIndex: 1, ID: 446, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribDivisorNV = builder.FunctionInfo{ApiIndex: 1, ID: 447, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlViewportArrayvNV = builder.FunctionInfo{ApiIndex: 1, ID: 448, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlViewportIndexedfNV = builder.FunctionInfo{ApiIndex: 1, ID: 449, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlViewportIndexedfvNV = builder.FunctionInfo{ApiIndex: 1, ID: 450, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlWaitSyncAPPLE = builder.FunctionInfo{ApiIndex: 1, ID: 451, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlWeightPathsNV = builder.FunctionInfo{ApiIndex: 1, ID: 452, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClearPixelLocalStorageuiEXT = builder.FunctionInfo{ApiIndex: 1, ID: 453, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlClearTexImageEXT = builder.FunctionInfo{ApiIndex: 1, ID: 454, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlClearTexSubImageEXT = builder.FunctionInfo{ApiIndex: 1, ID: 455, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlConservativeRasterParameteriNV = builder.FunctionInfo{ApiIndex: 1, ID: 456, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthRangeArrayfvOES = builder.FunctionInfo{ApiIndex: 1, ID: 457, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDepthRangeIndexedfOES = builder.FunctionInfo{ApiIndex: 1, ID: 458, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDrawTransformFeedbackEXT = builder.FunctionInfo{ApiIndex: 1, ID: 459, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDrawTransformFeedbackInstancedEXT = builder.FunctionInfo{ApiIndex: 1, ID: 460, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlFramebufferPixelLocalStorageSizeEXT = builder.FunctionInfo{ApiIndex: 1, ID: 461, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFramebufferTexture2DDownsampleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 462, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlFramebufferTextureLayerDownsampleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 463, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlFramebufferTextureMultisampleMultiviewOVR = builder.FunctionInfo{ApiIndex: 1, ID: 464, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlGetFloati_vOES = builder.FunctionInfo{ApiIndex: 1, ID: 465, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetFramebufferPixelLocalStorageSizeEXT = builder.FunctionInfo{ApiIndex: 1, ID: 466, ReturnType: protocol.Type_Int32, Parameters: 1}
var funcInfoGlGetTextureHandleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 467, ReturnType: protocol.Type_Uint64, Parameters: 1}
var funcInfoGlGetTextureSamplerHandleIMG = builder.FunctionInfo{ApiIndex: 1, ID: 468, ReturnType: protocol.Type_Uint64, Parameters: 2}
var funcInfoGlGetUniformi64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 469, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPolygonOffsetClampEXT = builder.FunctionInfo{ApiIndex: 1, ID: 470, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 471, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 472, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform1ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 473, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 474, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 475, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 476, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 477, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 478, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 479, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 480, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 481, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 482, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 483, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 484, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 485, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 486, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniformHandleui64IMG = builder.FunctionInfo{ApiIndex: 1, ID: 487, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniformHandleui64vIMG = builder.FunctionInfo{ApiIndex: 1, ID: 488, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlScissorArrayvOES = builder.FunctionInfo{ApiIndex: 1, ID: 489, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlScissorIndexedOES = builder.FunctionInfo{ApiIndex: 1, ID: 490, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlScissorIndexedvOES = builder.FunctionInfo{ApiIndex: 1, ID: 491, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 492, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 493, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform1ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 494, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 495, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 496, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 497, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 498, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 499, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform3i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 500, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform3i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 501, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform3ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 502, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform3ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 503, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform4i64NV = builder.FunctionInfo{ApiIndex: 1, ID: 504, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlUniform4i64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 505, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform4ui64NV = builder.FunctionInfo{ApiIndex: 1, ID: 506, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlUniform4ui64vNV = builder.FunctionInfo{ApiIndex: 1, ID: 507, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniformHandleui64IMG = builder.FunctionInfo{ApiIndex: 1, ID: 508, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniformHandleui64vIMG = builder.FunctionInfo{ApiIndex: 1, ID: 509, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlViewportArrayvOES = builder.FunctionInfo{ApiIndex: 1, ID: 510, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlViewportIndexedfOES = builder.FunctionInfo{ApiIndex: 1, ID: 511, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlViewportIndexedfvOES = builder.FunctionInfo{ApiIndex: 1, ID: 512, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlViewportSwizzleNV = builder.FunctionInfo{ApiIndex: 1, ID: 513, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlWindowRectanglesEXT = builder.FunctionInfo{ApiIndex: 1, ID: 514, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBlendBarrier = builder.FunctionInfo{ApiIndex: 1, ID: 515, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlBlendColor = builder.FunctionInfo{ApiIndex: 1, ID: 516, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBlendEquation = builder.FunctionInfo{ApiIndex: 1, ID: 517, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBlendEquationSeparate = builder.FunctionInfo{ApiIndex: 1, ID: 518, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendEquationSeparatei = builder.FunctionInfo{ApiIndex: 1, ID: 519, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBlendEquationi = builder.FunctionInfo{ApiIndex: 1, ID: 520, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendFunc = builder.FunctionInfo{ApiIndex: 1, ID: 521, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendFuncSeparate = builder.FunctionInfo{ApiIndex: 1, ID: 522, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBlendFuncSeparatei = builder.FunctionInfo{ApiIndex: 1, ID: 523, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlBlendFunci = builder.FunctionInfo{ApiIndex: 1, ID: 524, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDepthFunc = builder.FunctionInfo{ApiIndex: 1, ID: 525, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlSampleCoverage = builder.FunctionInfo{ApiIndex: 1, ID: 526, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlSampleMaski = builder.FunctionInfo{ApiIndex: 1, ID: 527, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlScissor = builder.FunctionInfo{ApiIndex: 1, ID: 528, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlStencilFunc = builder.FunctionInfo{ApiIndex: 1, ID: 529, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlStencilFuncSeparate = builder.FunctionInfo{ApiIndex: 1, ID: 530, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlStencilOp = builder.FunctionInfo{ApiIndex: 1, ID: 531, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlStencilOpSeparate = builder.FunctionInfo{ApiIndex: 1, ID: 532, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBindFramebuffer = builder.FunctionInfo{ApiIndex: 1, ID: 533, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindRenderbuffer = builder.FunctionInfo{ApiIndex: 1, ID: 534, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlitFramebuffer = builder.FunctionInfo{ApiIndex: 1, ID: 535, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlCheckFramebufferStatus = builder.FunctionInfo{ApiIndex: 1, ID: 536, ReturnType: protocol.Type_Uint32, Parameters: 1}
var funcInfoGlClear = builder.FunctionInfo{ApiIndex: 1, ID: 537, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClearBufferfi = builder.FunctionInfo{ApiIndex: 1, ID: 538, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClearBufferfv = builder.FunctionInfo{ApiIndex: 1, ID: 539, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlClearBufferiv = builder.FunctionInfo{ApiIndex: 1, ID: 540, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlClearBufferuiv = builder.FunctionInfo{ApiIndex: 1, ID: 541, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlClearColor = builder.FunctionInfo{ApiIndex: 1, ID: 542, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClearDepthf = builder.FunctionInfo{ApiIndex: 1, ID: 543, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClearStencil = builder.FunctionInfo{ApiIndex: 1, ID: 544, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlColorMask = builder.FunctionInfo{ApiIndex: 1, ID: 545, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColorMaski = builder.FunctionInfo{ApiIndex: 1, ID: 546, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDeleteFramebuffers = builder.FunctionInfo{ApiIndex: 1, ID: 547, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteRenderbuffers = builder.FunctionInfo{ApiIndex: 1, ID: 548, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthMask = builder.FunctionInfo{ApiIndex: 1, ID: 549, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDrawBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 550, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFramebufferParameteri = builder.FunctionInfo{ApiIndex: 1, ID: 551, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlFramebufferRenderbuffer = builder.FunctionInfo{ApiIndex: 1, ID: 552, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlFramebufferTexture = builder.FunctionInfo{ApiIndex: 1, ID: 553, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlFramebufferTexture2D = builder.FunctionInfo{ApiIndex: 1, ID: 554, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlFramebufferTextureLayer = builder.FunctionInfo{ApiIndex: 1, ID: 555, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGenFramebuffers = builder.FunctionInfo{ApiIndex: 1, ID: 556, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenRenderbuffers = builder.FunctionInfo{ApiIndex: 1, ID: 557, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetFramebufferAttachmentParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 558, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetFramebufferParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 559, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetRenderbufferParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 560, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlInvalidateFramebuffer = builder.FunctionInfo{ApiIndex: 1, ID: 561, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlInvalidateSubFramebuffer = builder.FunctionInfo{ApiIndex: 1, ID: 562, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlIsFramebuffer = builder.FunctionInfo{ApiIndex: 1, ID: 563, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsRenderbuffer = builder.FunctionInfo{ApiIndex: 1, ID: 564, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlReadBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 565, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlReadPixels = builder.FunctionInfo{ApiIndex: 1, ID: 566, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlReadnPixels = builder.FunctionInfo{ApiIndex: 1, ID: 567, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlRenderbufferStorage = builder.FunctionInfo{ApiIndex: 1, ID: 568, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlRenderbufferStorageMultisample = builder.FunctionInfo{ApiIndex: 1, ID: 569, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlStencilMask = builder.FunctionInfo{ApiIndex: 1, ID: 570, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlStencilMaskSeparate = builder.FunctionInfo{ApiIndex: 1, ID: 571, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDisable = builder.FunctionInfo{ApiIndex: 1, ID: 572, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDisablei = builder.FunctionInfo{ApiIndex: 1, ID: 573, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEnable = builder.FunctionInfo{ApiIndex: 1, ID: 574, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEnablei = builder.FunctionInfo{ApiIndex: 1, ID: 575, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFinish = builder.FunctionInfo{ApiIndex: 1, ID: 576, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlFlush = builder.FunctionInfo{ApiIndex: 1, ID: 577, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlGetError = builder.FunctionInfo{ApiIndex: 1, ID: 578, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoGlGetGraphicsResetStatus = builder.FunctionInfo{ApiIndex: 1, ID: 579, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoGlHint = builder.FunctionInfo{ApiIndex: 1, ID: 580, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlActiveShaderProgram = builder.FunctionInfo{ApiIndex: 1, ID: 581, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlAttachShader = builder.FunctionInfo{ApiIndex: 1, ID: 582, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindAttribLocation = builder.FunctionInfo{ApiIndex: 1, ID: 583, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlBindProgramPipeline = builder.FunctionInfo{ApiIndex: 1, ID: 584, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCompileShader = builder.FunctionInfo{ApiIndex: 1, ID: 585, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCreateProgram = builder.FunctionInfo{ApiIndex: 1, ID: 586, ReturnType: protocol.Type_Uint32, Parameters: 0}
var funcInfoGlCreateShader = builder.FunctionInfo{ApiIndex: 1, ID: 587, ReturnType: protocol.Type_Uint32, Parameters: 1}
var funcInfoGlCreateShaderProgramv = builder.FunctionInfo{ApiIndex: 1, ID: 588, ReturnType: protocol.Type_Uint32, Parameters: 3}
var funcInfoGlDeleteProgram = builder.FunctionInfo{ApiIndex: 1, ID: 589, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDeleteProgramPipelines = builder.FunctionInfo{ApiIndex: 1, ID: 590, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteShader = builder.FunctionInfo{ApiIndex: 1, ID: 591, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDetachShader = builder.FunctionInfo{ApiIndex: 1, ID: 592, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDispatchCompute = builder.FunctionInfo{ApiIndex: 1, ID: 593, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlDispatchComputeIndirect = builder.FunctionInfo{ApiIndex: 1, ID: 594, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGenProgramPipelines = builder.FunctionInfo{ApiIndex: 1, ID: 595, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetActiveAttrib = builder.FunctionInfo{ApiIndex: 1, ID: 596, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlGetActiveUniform = builder.FunctionInfo{ApiIndex: 1, ID: 597, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlGetActiveUniformBlockName = builder.FunctionInfo{ApiIndex: 1, ID: 598, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetActiveUniformBlockiv = builder.FunctionInfo{ApiIndex: 1, ID: 599, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetActiveUniformsiv = builder.FunctionInfo{ApiIndex: 1, ID: 600, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetAttachedShaders = builder.FunctionInfo{ApiIndex: 1, ID: 601, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetAttribLocation = builder.FunctionInfo{ApiIndex: 1, ID: 602, ReturnType: protocol.Type_Int32, Parameters: 2}
var funcInfoGlGetFragDataLocation = builder.FunctionInfo{ApiIndex: 1, ID: 603, ReturnType: protocol.Type_Int32, Parameters: 2}
var funcInfoGlGetProgramBinary = builder.FunctionInfo{ApiIndex: 1, ID: 604, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetProgramInfoLog = builder.FunctionInfo{ApiIndex: 1, ID: 605, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetProgramInterfaceiv = builder.FunctionInfo{ApiIndex: 1, ID: 606, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetProgramPipelineInfoLog = builder.FunctionInfo{ApiIndex: 1, ID: 607, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetProgramPipelineiv = builder.FunctionInfo{ApiIndex: 1, ID: 608, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetProgramResourceIndex = builder.FunctionInfo{ApiIndex: 1, ID: 609, ReturnType: protocol.Type_Uint32, Parameters: 3}
var funcInfoGlGetProgramResourceLocation = builder.FunctionInfo{ApiIndex: 1, ID: 610, ReturnType: protocol.Type_Int32, Parameters: 3}
var funcInfoGlGetProgramResourceName = builder.FunctionInfo{ApiIndex: 1, ID: 611, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlGetProgramResourceiv = builder.FunctionInfo{ApiIndex: 1, ID: 612, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlGetProgramiv = builder.FunctionInfo{ApiIndex: 1, ID: 613, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetShaderInfoLog = builder.FunctionInfo{ApiIndex: 1, ID: 614, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetShaderPrecisionFormat = builder.FunctionInfo{ApiIndex: 1, ID: 615, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetShaderSource = builder.FunctionInfo{ApiIndex: 1, ID: 616, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetShaderiv = builder.FunctionInfo{ApiIndex: 1, ID: 617, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetUniformBlockIndex = builder.FunctionInfo{ApiIndex: 1, ID: 618, ReturnType: protocol.Type_Uint32, Parameters: 2}
var funcInfoGlGetUniformIndices = builder.FunctionInfo{ApiIndex: 1, ID: 619, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetUniformLocation = builder.FunctionInfo{ApiIndex: 1, ID: 620, ReturnType: protocol.Type_Int32, Parameters: 2}
var funcInfoGlGetUniformfv = builder.FunctionInfo{ApiIndex: 1, ID: 621, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetUniformiv = builder.FunctionInfo{ApiIndex: 1, ID: 622, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetUniformuiv = builder.FunctionInfo{ApiIndex: 1, ID: 623, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetnUniformfv = builder.FunctionInfo{ApiIndex: 1, ID: 624, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformiv = builder.FunctionInfo{ApiIndex: 1, ID: 625, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetnUniformuiv = builder.FunctionInfo{ApiIndex: 1, ID: 626, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlIsProgram = builder.FunctionInfo{ApiIndex: 1, ID: 627, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsProgramPipeline = builder.FunctionInfo{ApiIndex: 1, ID: 628, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsShader = builder.FunctionInfo{ApiIndex: 1, ID: 629, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlLinkProgram = builder.FunctionInfo{ApiIndex: 1, ID: 630, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMemoryBarrier = builder.FunctionInfo{ApiIndex: 1, ID: 631, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMemoryBarrierByRegion = builder.FunctionInfo{ApiIndex: 1, ID: 632, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlProgramBinary = builder.FunctionInfo{ApiIndex: 1, ID: 633, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramParameteri = builder.FunctionInfo{ApiIndex: 1, ID: 634, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1f = builder.FunctionInfo{ApiIndex: 1, ID: 635, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1fv = builder.FunctionInfo{ApiIndex: 1, ID: 636, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform1i = builder.FunctionInfo{ApiIndex: 1, ID: 637, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1iv = builder.FunctionInfo{ApiIndex: 1, ID: 638, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform1ui = builder.FunctionInfo{ApiIndex: 1, ID: 639, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlProgramUniform1uiv = builder.FunctionInfo{ApiIndex: 1, ID: 640, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2f = builder.FunctionInfo{ApiIndex: 1, ID: 641, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2fv = builder.FunctionInfo{ApiIndex: 1, ID: 642, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2i = builder.FunctionInfo{ApiIndex: 1, ID: 643, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2iv = builder.FunctionInfo{ApiIndex: 1, ID: 644, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2ui = builder.FunctionInfo{ApiIndex: 1, ID: 645, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform2uiv = builder.FunctionInfo{ApiIndex: 1, ID: 646, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3f = builder.FunctionInfo{ApiIndex: 1, ID: 647, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3fv = builder.FunctionInfo{ApiIndex: 1, ID: 648, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3i = builder.FunctionInfo{ApiIndex: 1, ID: 649, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3iv = builder.FunctionInfo{ApiIndex: 1, ID: 650, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform3ui = builder.FunctionInfo{ApiIndex: 1, ID: 651, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniform3uiv = builder.FunctionInfo{ApiIndex: 1, ID: 652, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4f = builder.FunctionInfo{ApiIndex: 1, ID: 653, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4fv = builder.FunctionInfo{ApiIndex: 1, ID: 654, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4i = builder.FunctionInfo{ApiIndex: 1, ID: 655, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4iv = builder.FunctionInfo{ApiIndex: 1, ID: 656, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniform4ui = builder.FunctionInfo{ApiIndex: 1, ID: 657, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlProgramUniform4uiv = builder.FunctionInfo{ApiIndex: 1, ID: 658, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlProgramUniformMatrix2fv = builder.FunctionInfo{ApiIndex: 1, ID: 659, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix2x3fv = builder.FunctionInfo{ApiIndex: 1, ID: 660, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix2x4fv = builder.FunctionInfo{ApiIndex: 1, ID: 661, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3fv = builder.FunctionInfo{ApiIndex: 1, ID: 662, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3x2fv = builder.FunctionInfo{ApiIndex: 1, ID: 663, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix3x4fv = builder.FunctionInfo{ApiIndex: 1, ID: 664, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4fv = builder.FunctionInfo{ApiIndex: 1, ID: 665, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4x2fv = builder.FunctionInfo{ApiIndex: 1, ID: 666, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlProgramUniformMatrix4x3fv = builder.FunctionInfo{ApiIndex: 1, ID: 667, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlReleaseShaderCompiler = builder.FunctionInfo{ApiIndex: 1, ID: 668, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlShaderBinary = builder.FunctionInfo{ApiIndex: 1, ID: 669, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlShaderSource = builder.FunctionInfo{ApiIndex: 1, ID: 670, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform1f = builder.FunctionInfo{ApiIndex: 1, ID: 671, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1fv = builder.FunctionInfo{ApiIndex: 1, ID: 672, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform1i = builder.FunctionInfo{ApiIndex: 1, ID: 673, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1iv = builder.FunctionInfo{ApiIndex: 1, ID: 674, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform1ui = builder.FunctionInfo{ApiIndex: 1, ID: 675, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlUniform1uiv = builder.FunctionInfo{ApiIndex: 1, ID: 676, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2f = builder.FunctionInfo{ApiIndex: 1, ID: 677, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2fv = builder.FunctionInfo{ApiIndex: 1, ID: 678, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2i = builder.FunctionInfo{ApiIndex: 1, ID: 679, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2iv = builder.FunctionInfo{ApiIndex: 1, ID: 680, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2ui = builder.FunctionInfo{ApiIndex: 1, ID: 681, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform2uiv = builder.FunctionInfo{ApiIndex: 1, ID: 682, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform3f = builder.FunctionInfo{ApiIndex: 1, ID: 683, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform3fv = builder.FunctionInfo{ApiIndex: 1, ID: 684, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform3i = builder.FunctionInfo{ApiIndex: 1, ID: 685, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform3iv = builder.FunctionInfo{ApiIndex: 1, ID: 686, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform3ui = builder.FunctionInfo{ApiIndex: 1, ID: 687, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniform3uiv = builder.FunctionInfo{ApiIndex: 1, ID: 688, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform4f = builder.FunctionInfo{ApiIndex: 1, ID: 689, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlUniform4fv = builder.FunctionInfo{ApiIndex: 1, ID: 690, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform4i = builder.FunctionInfo{ApiIndex: 1, ID: 691, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlUniform4iv = builder.FunctionInfo{ApiIndex: 1, ID: 692, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniform4ui = builder.FunctionInfo{ApiIndex: 1, ID: 693, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlUniform4uiv = builder.FunctionInfo{ApiIndex: 1, ID: 694, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniformBlockBinding = builder.FunctionInfo{ApiIndex: 1, ID: 695, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlUniformMatrix2fv = builder.FunctionInfo{ApiIndex: 1, ID: 696, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix2x3fv = builder.FunctionInfo{ApiIndex: 1, ID: 697, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix2x4fv = builder.FunctionInfo{ApiIndex: 1, ID: 698, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix3fv = builder.FunctionInfo{ApiIndex: 1, ID: 699, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix3x2fv = builder.FunctionInfo{ApiIndex: 1, ID: 700, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix3x4fv = builder.FunctionInfo{ApiIndex: 1, ID: 701, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix4fv = builder.FunctionInfo{ApiIndex: 1, ID: 702, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix4x2fv = builder.FunctionInfo{ApiIndex: 1, ID: 703, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUniformMatrix4x3fv = builder.FunctionInfo{ApiIndex: 1, ID: 704, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlUseProgram = builder.FunctionInfo{ApiIndex: 1, ID: 705, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlUseProgramStages = builder.FunctionInfo{ApiIndex: 1, ID: 706, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlValidateProgram = builder.FunctionInfo{ApiIndex: 1, ID: 707, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlValidateProgramPipeline = builder.FunctionInfo{ApiIndex: 1, ID: 708, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlCullFace = builder.FunctionInfo{ApiIndex: 1, ID: 709, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDepthRangef = builder.FunctionInfo{ApiIndex: 1, ID: 710, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFrontFace = builder.FunctionInfo{ApiIndex: 1, ID: 711, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGetMultisamplefv = builder.FunctionInfo{ApiIndex: 1, ID: 712, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLineWidth = builder.FunctionInfo{ApiIndex: 1, ID: 713, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMinSampleShading = builder.FunctionInfo{ApiIndex: 1, ID: 714, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlPolygonOffset = builder.FunctionInfo{ApiIndex: 1, ID: 715, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlViewport = builder.FunctionInfo{ApiIndex: 1, ID: 716, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetBooleani_v = builder.FunctionInfo{ApiIndex: 1, ID: 717, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetBooleanv = builder.FunctionInfo{ApiIndex: 1, ID: 718, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetFloatv = builder.FunctionInfo{ApiIndex: 1, ID: 719, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetInteger64i_v = builder.FunctionInfo{ApiIndex: 1, ID: 720, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetInteger64v = builder.FunctionInfo{ApiIndex: 1, ID: 721, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetIntegeri_v = builder.FunctionInfo{ApiIndex: 1, ID: 722, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetIntegerv = builder.FunctionInfo{ApiIndex: 1, ID: 723, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetInternalformativ = builder.FunctionInfo{ApiIndex: 1, ID: 724, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlGetString = builder.FunctionInfo{ApiIndex: 1, ID: 725, ReturnType: protocol.Type_AbsolutePointer, Parameters: 1}
var funcInfoGlGetStringi = builder.FunctionInfo{ApiIndex: 1, ID: 726, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoGlIsEnabled = builder.FunctionInfo{ApiIndex: 1, ID: 727, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsEnabledi = builder.FunctionInfo{ApiIndex: 1, ID: 728, ReturnType: protocol.Type_Uint8, Parameters: 2}
var funcInfoGlClientWaitSync = builder.FunctionInfo{ApiIndex: 1, ID: 729, ReturnType: protocol.Type_Uint32, Parameters: 3}
var funcInfoGlDeleteSync = builder.FunctionInfo{ApiIndex: 1, ID: 730, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlFenceSync = builder.FunctionInfo{ApiIndex: 1, ID: 731, ReturnType: protocol.Type_AbsolutePointer, Parameters: 2}
var funcInfoGlGetSynciv = builder.FunctionInfo{ApiIndex: 1, ID: 732, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlIsSync = builder.FunctionInfo{ApiIndex: 1, ID: 733, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlWaitSync = builder.FunctionInfo{ApiIndex: 1, ID: 734, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlActiveTexture = builder.FunctionInfo{ApiIndex: 1, ID: 735, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBindImageTexture = builder.FunctionInfo{ApiIndex: 1, ID: 736, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlBindSampler = builder.FunctionInfo{ApiIndex: 1, ID: 737, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindTexture = builder.FunctionInfo{ApiIndex: 1, ID: 738, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlCompressedTexImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 739, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlCompressedTexImage3D = builder.FunctionInfo{ApiIndex: 1, ID: 740, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlCompressedTexSubImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 741, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlCompressedTexSubImage3D = builder.FunctionInfo{ApiIndex: 1, ID: 742, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlCopyImageSubData = builder.FunctionInfo{ApiIndex: 1, ID: 743, ReturnType: protocol.Type_Void, Parameters: 15}
var funcInfoGlCopyTexImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 744, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlCopyTexSubImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 745, ReturnType: protocol.Type_Void, Parameters: 8}
var funcInfoGlCopyTexSubImage3D = builder.FunctionInfo{ApiIndex: 1, ID: 746, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlDeleteSamplers = builder.FunctionInfo{ApiIndex: 1, ID: 747, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteTextures = builder.FunctionInfo{ApiIndex: 1, ID: 748, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenSamplers = builder.FunctionInfo{ApiIndex: 1, ID: 749, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenTextures = builder.FunctionInfo{ApiIndex: 1, ID: 750, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenerateMipmap = builder.FunctionInfo{ApiIndex: 1, ID: 751, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGetSamplerParameterIiv = builder.FunctionInfo{ApiIndex: 1, ID: 752, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameterIuiv = builder.FunctionInfo{ApiIndex: 1, ID: 753, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 754, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetSamplerParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 755, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexLevelParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 756, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetTexLevelParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 757, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetTexParameterIiv = builder.FunctionInfo{ApiIndex: 1, ID: 758, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterIuiv = builder.FunctionInfo{ApiIndex: 1, ID: 759, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 760, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 761, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsSampler = builder.FunctionInfo{ApiIndex: 1, ID: 762, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsTexture = builder.FunctionInfo{ApiIndex: 1, ID: 763, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlPixelStorei = builder.FunctionInfo{ApiIndex: 1, ID: 764, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlSamplerParameterIiv = builder.FunctionInfo{ApiIndex: 1, ID: 765, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameterIuiv = builder.FunctionInfo{ApiIndex: 1, ID: 766, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameterf = builder.FunctionInfo{ApiIndex: 1, ID: 767, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 768, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameteri = builder.FunctionInfo{ApiIndex: 1, ID: 769, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlSamplerParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 770, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 771, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexBufferRange = builder.FunctionInfo{ApiIndex: 1, ID: 772, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTexImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 773, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlTexImage3D = builder.FunctionInfo{ApiIndex: 1, ID: 774, ReturnType: protocol.Type_Void, Parameters: 10}
var funcInfoGlTexParameterIiv = builder.FunctionInfo{ApiIndex: 1, ID: 775, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterIuiv = builder.FunctionInfo{ApiIndex: 1, ID: 776, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterf = builder.FunctionInfo{ApiIndex: 1, ID: 777, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 778, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameteri = builder.FunctionInfo{ApiIndex: 1, ID: 779, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameteriv = builder.FunctionInfo{ApiIndex: 1, ID: 780, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexStorage2D = builder.FunctionInfo{ApiIndex: 1, ID: 781, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlTexStorage2DMultisample = builder.FunctionInfo{ApiIndex: 1, ID: 782, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlTexStorage3D = builder.FunctionInfo{ApiIndex: 1, ID: 783, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlTexStorage3DMultisample = builder.FunctionInfo{ApiIndex: 1, ID: 784, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlTexSubImage2D = builder.FunctionInfo{ApiIndex: 1, ID: 785, ReturnType: protocol.Type_Void, Parameters: 9}
var funcInfoGlTexSubImage3D = builder.FunctionInfo{ApiIndex: 1, ID: 786, ReturnType: protocol.Type_Void, Parameters: 11}
var funcInfoGlBeginTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 787, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBindTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 788, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteTransformFeedbacks = builder.FunctionInfo{ApiIndex: 1, ID: 789, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlEndTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 790, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlGenTransformFeedbacks = builder.FunctionInfo{ApiIndex: 1, ID: 791, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetTransformFeedbackVarying = builder.FunctionInfo{ApiIndex: 1, ID: 792, ReturnType: protocol.Type_Void, Parameters: 7}
var funcInfoGlIsTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 793, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlPauseTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 794, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlResumeTransformFeedback = builder.FunctionInfo{ApiIndex: 1, ID: 795, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlTransformFeedbackVaryings = builder.FunctionInfo{ApiIndex: 1, ID: 796, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBindVertexArray = builder.FunctionInfo{ApiIndex: 1, ID: 797, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBindVertexBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 798, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlDeleteVertexArrays = builder.FunctionInfo{ApiIndex: 1, ID: 799, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDisableVertexAttribArray = builder.FunctionInfo{ApiIndex: 1, ID: 800, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEnableVertexAttribArray = builder.FunctionInfo{ApiIndex: 1, ID: 801, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGenVertexArrays = builder.FunctionInfo{ApiIndex: 1, ID: 802, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetVertexAttribIiv = builder.FunctionInfo{ApiIndex: 1, ID: 803, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetVertexAttribIuiv = builder.FunctionInfo{ApiIndex: 1, ID: 804, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetVertexAttribPointerv = builder.FunctionInfo{ApiIndex: 1, ID: 805, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetVertexAttribfv = builder.FunctionInfo{ApiIndex: 1, ID: 806, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetVertexAttribiv = builder.FunctionInfo{ApiIndex: 1, ID: 807, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsVertexArray = builder.FunctionInfo{ApiIndex: 1, ID: 808, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlVertexAttrib1f = builder.FunctionInfo{ApiIndex: 1, ID: 809, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttrib1fv = builder.FunctionInfo{ApiIndex: 1, ID: 810, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttrib2f = builder.FunctionInfo{ApiIndex: 1, ID: 811, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlVertexAttrib2fv = builder.FunctionInfo{ApiIndex: 1, ID: 812, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttrib3f = builder.FunctionInfo{ApiIndex: 1, ID: 813, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlVertexAttrib3fv = builder.FunctionInfo{ApiIndex: 1, ID: 814, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttrib4f = builder.FunctionInfo{ApiIndex: 1, ID: 815, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexAttrib4fv = builder.FunctionInfo{ApiIndex: 1, ID: 816, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribBinding = builder.FunctionInfo{ApiIndex: 1, ID: 817, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribDivisor = builder.FunctionInfo{ApiIndex: 1, ID: 818, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribFormat = builder.FunctionInfo{ApiIndex: 1, ID: 819, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexAttribI4i = builder.FunctionInfo{ApiIndex: 1, ID: 820, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexAttribI4iv = builder.FunctionInfo{ApiIndex: 1, ID: 821, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribI4ui = builder.FunctionInfo{ApiIndex: 1, ID: 822, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexAttribI4uiv = builder.FunctionInfo{ApiIndex: 1, ID: 823, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlVertexAttribIFormat = builder.FunctionInfo{ApiIndex: 1, ID: 824, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlVertexAttribIPointer = builder.FunctionInfo{ApiIndex: 1, ID: 825, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexAttribPointer = builder.FunctionInfo{ApiIndex: 1, ID: 826, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlVertexBindingDivisor = builder.FunctionInfo{ApiIndex: 1, ID: 827, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlXCreateContext = builder.FunctionInfo{ApiIndex: 1, ID: 828, ReturnType: protocol.Type_AbsolutePointer, Parameters: 4}
var funcInfoGlXCreateNewContext = builder.FunctionInfo{ApiIndex: 1, ID: 829, ReturnType: protocol.Type_AbsolutePointer, Parameters: 5}
var funcInfoGlXMakeContextCurrent = builder.FunctionInfo{ApiIndex: 1, ID: 830, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoGlXMakeCurrent = builder.FunctionInfo{ApiIndex: 1, ID: 831, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoGlXSwapBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 832, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlXQueryDrawable = builder.FunctionInfo{ApiIndex: 1, ID: 833, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoWglCreateContext = builder.FunctionInfo{ApiIndex: 1, ID: 834, ReturnType: protocol.Type_AbsolutePointer, Parameters: 1}
var funcInfoWglCreateContextAttribsARB = builder.FunctionInfo{ApiIndex: 1, ID: 835, ReturnType: protocol.Type_AbsolutePointer, Parameters: 3}
var funcInfoWglMakeCurrent = builder.FunctionInfo{ApiIndex: 1, ID: 836, ReturnType: protocol.Type_Int64, Parameters: 2}
var funcInfoWglSwapBuffers = builder.FunctionInfo{ApiIndex: 1, ID: 837, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoCGLCreateContext = builder.FunctionInfo{ApiIndex: 1, ID: 838, ReturnType: protocol.Type_Int64, Parameters: 3}
var funcInfoCGLSetCurrentContext = builder.FunctionInfo{ApiIndex: 1, ID: 839, ReturnType: protocol.Type_Int64, Parameters: 1}
var funcInfoCGLGetSurface = builder.FunctionInfo{ApiIndex: 1, ID: 840, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoCGSGetSurfaceBounds = builder.FunctionInfo{ApiIndex: 1, ID: 841, ReturnType: protocol.Type_Int64, Parameters: 4}
var funcInfoCGLFlushDrawable = builder.FunctionInfo{ApiIndex: 1, ID: 842, ReturnType: protocol.Type_Int64, Parameters: 1}
var funcInfoGlGetQueryObjecti64v = builder.FunctionInfo{ApiIndex: 1, ID: 843, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetQueryObjectui64v = builder.FunctionInfo{ApiIndex: 1, ID: 844, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexStorage1D = builder.FunctionInfo{ApiIndex: 1, ID: 845, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlBindFragDataLocation = builder.FunctionInfo{ApiIndex: 1, ID: 846, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlAlphaFunc = builder.FunctionInfo{ApiIndex: 1, ID: 847, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlAlphaFuncx = builder.FunctionInfo{ApiIndex: 1, ID: 848, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlAlphaFuncxOES = builder.FunctionInfo{ApiIndex: 1, ID: 849, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindFramebufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 850, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBindRenderbufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 851, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendEquationOES = builder.FunctionInfo{ApiIndex: 1, ID: 852, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlBlendEquationSeparateOES = builder.FunctionInfo{ApiIndex: 1, ID: 853, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlBlendFuncSeparateOES = builder.FunctionInfo{ApiIndex: 1, ID: 854, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlCheckFramebufferStatusOES = builder.FunctionInfo{ApiIndex: 1, ID: 855, ReturnType: protocol.Type_Uint32, Parameters: 1}
var funcInfoGlClearColorx = builder.FunctionInfo{ApiIndex: 1, ID: 856, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClearColorxOES = builder.FunctionInfo{ApiIndex: 1, ID: 857, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlClearDepthfOES = builder.FunctionInfo{ApiIndex: 1, ID: 858, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClearDepthx = builder.FunctionInfo{ApiIndex: 1, ID: 859, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClearDepthxOES = builder.FunctionInfo{ApiIndex: 1, ID: 860, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClientActiveTexture = builder.FunctionInfo{ApiIndex: 1, ID: 861, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlClipPlanef = builder.FunctionInfo{ApiIndex: 1, ID: 862, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlClipPlanefIMG = builder.FunctionInfo{ApiIndex: 1, ID: 863, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlClipPlanefOES = builder.FunctionInfo{ApiIndex: 1, ID: 864, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlClipPlanex = builder.FunctionInfo{ApiIndex: 1, ID: 865, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlClipPlanexIMG = builder.FunctionInfo{ApiIndex: 1, ID: 866, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlClipPlanexOES = builder.FunctionInfo{ApiIndex: 1, ID: 867, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlColor4f = builder.FunctionInfo{ApiIndex: 1, ID: 868, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColor4ub = builder.FunctionInfo{ApiIndex: 1, ID: 869, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColor4x = builder.FunctionInfo{ApiIndex: 1, ID: 870, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColor4xOES = builder.FunctionInfo{ApiIndex: 1, ID: 871, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColorPointer = builder.FunctionInfo{ApiIndex: 1, ID: 872, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlCurrentPaletteMatrixOES = builder.FunctionInfo{ApiIndex: 1, ID: 873, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDeleteFramebuffersOES = builder.FunctionInfo{ApiIndex: 1, ID: 874, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDeleteRenderbuffersOES = builder.FunctionInfo{ApiIndex: 1, ID: 875, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthRangefOES = builder.FunctionInfo{ApiIndex: 1, ID: 876, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthRangex = builder.FunctionInfo{ApiIndex: 1, ID: 877, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDepthRangexOES = builder.FunctionInfo{ApiIndex: 1, ID: 878, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlDisableClientState = builder.FunctionInfo{ApiIndex: 1, ID: 879, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDrawTexfOES = builder.FunctionInfo{ApiIndex: 1, ID: 880, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawTexfvOES = builder.FunctionInfo{ApiIndex: 1, ID: 881, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDrawTexiOES = builder.FunctionInfo{ApiIndex: 1, ID: 882, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawTexivOES = builder.FunctionInfo{ApiIndex: 1, ID: 883, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDrawTexsOES = builder.FunctionInfo{ApiIndex: 1, ID: 884, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawTexsvOES = builder.FunctionInfo{ApiIndex: 1, ID: 885, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlDrawTexxOES = builder.FunctionInfo{ApiIndex: 1, ID: 886, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlDrawTexxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 887, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlEnableClientState = builder.FunctionInfo{ApiIndex: 1, ID: 888, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlFogf = builder.FunctionInfo{ApiIndex: 1, ID: 889, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFogfv = builder.FunctionInfo{ApiIndex: 1, ID: 890, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFogx = builder.FunctionInfo{ApiIndex: 1, ID: 891, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFogxOES = builder.FunctionInfo{ApiIndex: 1, ID: 892, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFogxv = builder.FunctionInfo{ApiIndex: 1, ID: 893, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFogxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 894, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlFramebufferRenderbufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 895, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlFramebufferTexture2DOES = builder.FunctionInfo{ApiIndex: 1, ID: 896, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlFrustumf = builder.FunctionInfo{ApiIndex: 1, ID: 897, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFrustumfOES = builder.FunctionInfo{ApiIndex: 1, ID: 898, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFrustumx = builder.FunctionInfo{ApiIndex: 1, ID: 899, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlFrustumxOES = builder.FunctionInfo{ApiIndex: 1, ID: 900, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlGenFramebuffersOES = builder.FunctionInfo{ApiIndex: 1, ID: 901, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenRenderbuffersOES = builder.FunctionInfo{ApiIndex: 1, ID: 902, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGenerateMipmapOES = builder.FunctionInfo{ApiIndex: 1, ID: 903, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlGetClipPlanef = builder.FunctionInfo{ApiIndex: 1, ID: 904, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetClipPlanefOES = builder.FunctionInfo{ApiIndex: 1, ID: 905, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetClipPlanex = builder.FunctionInfo{ApiIndex: 1, ID: 906, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetClipPlanexOES = builder.FunctionInfo{ApiIndex: 1, ID: 907, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetFixedv = builder.FunctionInfo{ApiIndex: 1, ID: 908, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetFixedvOES = builder.FunctionInfo{ApiIndex: 1, ID: 909, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlGetFramebufferAttachmentParameterivOES = builder.FunctionInfo{ApiIndex: 1, ID: 910, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlGetLightfv = builder.FunctionInfo{ApiIndex: 1, ID: 911, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetLightxv = builder.FunctionInfo{ApiIndex: 1, ID: 912, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetLightxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 913, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetMaterialfv = builder.FunctionInfo{ApiIndex: 1, ID: 914, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetMaterialxv = builder.FunctionInfo{ApiIndex: 1, ID: 915, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetMaterialxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 916, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetRenderbufferParameterivOES = builder.FunctionInfo{ApiIndex: 1, ID: 917, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexEnvfv = builder.FunctionInfo{ApiIndex: 1, ID: 918, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexEnviv = builder.FunctionInfo{ApiIndex: 1, ID: 919, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexEnvxv = builder.FunctionInfo{ApiIndex: 1, ID: 920, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexEnvxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 921, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexGenfvOES = builder.FunctionInfo{ApiIndex: 1, ID: 922, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexGenivOES = builder.FunctionInfo{ApiIndex: 1, ID: 923, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexGenxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 924, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterxv = builder.FunctionInfo{ApiIndex: 1, ID: 925, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlGetTexParameterxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 926, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlIsFramebufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 927, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlIsRenderbufferOES = builder.FunctionInfo{ApiIndex: 1, ID: 928, ReturnType: protocol.Type_Uint8, Parameters: 1}
var funcInfoGlLightModelf = builder.FunctionInfo{ApiIndex: 1, ID: 929, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightModelfv = builder.FunctionInfo{ApiIndex: 1, ID: 930, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightModelx = builder.FunctionInfo{ApiIndex: 1, ID: 931, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightModelxOES = builder.FunctionInfo{ApiIndex: 1, ID: 932, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightModelxv = builder.FunctionInfo{ApiIndex: 1, ID: 933, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightModelxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 934, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlLightf = builder.FunctionInfo{ApiIndex: 1, ID: 935, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLightfv = builder.FunctionInfo{ApiIndex: 1, ID: 936, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLightx = builder.FunctionInfo{ApiIndex: 1, ID: 937, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLightxOES = builder.FunctionInfo{ApiIndex: 1, ID: 938, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLightxv = builder.FunctionInfo{ApiIndex: 1, ID: 939, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLightxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 940, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlLineWidthx = builder.FunctionInfo{ApiIndex: 1, ID: 941, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlLineWidthxOES = builder.FunctionInfo{ApiIndex: 1, ID: 942, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlLoadIdentity = builder.FunctionInfo{ApiIndex: 1, ID: 943, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlLoadMatrixf = builder.FunctionInfo{ApiIndex: 1, ID: 944, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlLoadMatrixx = builder.FunctionInfo{ApiIndex: 1, ID: 945, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlLoadMatrixxOES = builder.FunctionInfo{ApiIndex: 1, ID: 946, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlLoadPaletteFromModelViewMatrixOES = builder.FunctionInfo{ApiIndex: 1, ID: 947, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlLogicOp = builder.FunctionInfo{ApiIndex: 1, ID: 948, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMaterialf = builder.FunctionInfo{ApiIndex: 1, ID: 949, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMaterialfv = builder.FunctionInfo{ApiIndex: 1, ID: 950, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMaterialx = builder.FunctionInfo{ApiIndex: 1, ID: 951, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMaterialxOES = builder.FunctionInfo{ApiIndex: 1, ID: 952, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMaterialxv = builder.FunctionInfo{ApiIndex: 1, ID: 953, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMaterialxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 954, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlMatrixIndexPointerOES = builder.FunctionInfo{ApiIndex: 1, ID: 955, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlMatrixMode = builder.FunctionInfo{ApiIndex: 1, ID: 956, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMultMatrixf = builder.FunctionInfo{ApiIndex: 1, ID: 957, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMultMatrixx = builder.FunctionInfo{ApiIndex: 1, ID: 958, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMultMatrixxOES = builder.FunctionInfo{ApiIndex: 1, ID: 959, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlMultiTexCoord4f = builder.FunctionInfo{ApiIndex: 1, ID: 960, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlMultiTexCoord4x = builder.FunctionInfo{ApiIndex: 1, ID: 961, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlMultiTexCoord4xOES = builder.FunctionInfo{ApiIndex: 1, ID: 962, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlNormal3f = builder.FunctionInfo{ApiIndex: 1, ID: 963, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlNormal3x = builder.FunctionInfo{ApiIndex: 1, ID: 964, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlNormal3xOES = builder.FunctionInfo{ApiIndex: 1, ID: 965, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlNormalPointer = builder.FunctionInfo{ApiIndex: 1, ID: 966, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlOrthof = builder.FunctionInfo{ApiIndex: 1, ID: 967, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlOrthofOES = builder.FunctionInfo{ApiIndex: 1, ID: 968, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlOrthox = builder.FunctionInfo{ApiIndex: 1, ID: 969, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlOrthoxOES = builder.FunctionInfo{ApiIndex: 1, ID: 970, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoGlPointParameterf = builder.FunctionInfo{ApiIndex: 1, ID: 971, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointParameterfv = builder.FunctionInfo{ApiIndex: 1, ID: 972, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointParameterx = builder.FunctionInfo{ApiIndex: 1, ID: 973, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointParameterxOES = builder.FunctionInfo{ApiIndex: 1, ID: 974, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointParameterxv = builder.FunctionInfo{ApiIndex: 1, ID: 975, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointParameterxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 976, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPointSize = builder.FunctionInfo{ApiIndex: 1, ID: 977, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlPointSizePointerOES = builder.FunctionInfo{ApiIndex: 1, ID: 978, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlPointSizex = builder.FunctionInfo{ApiIndex: 1, ID: 979, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlPointSizexOES = builder.FunctionInfo{ApiIndex: 1, ID: 980, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlPolygonOffsetx = builder.FunctionInfo{ApiIndex: 1, ID: 981, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPolygonOffsetxOES = builder.FunctionInfo{ApiIndex: 1, ID: 982, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlPopMatrix = builder.FunctionInfo{ApiIndex: 1, ID: 983, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlPushMatrix = builder.FunctionInfo{ApiIndex: 1, ID: 984, ReturnType: protocol.Type_Void, Parameters: 0}
var funcInfoGlQueryMatrixxOES = builder.FunctionInfo{ApiIndex: 1, ID: 985, ReturnType: protocol.Type_Uint32, Parameters: 2}
var funcInfoGlRenderbufferStorageOES = builder.FunctionInfo{ApiIndex: 1, ID: 986, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlRotatef = builder.FunctionInfo{ApiIndex: 1, ID: 987, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlRotatex = builder.FunctionInfo{ApiIndex: 1, ID: 988, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlRotatexOES = builder.FunctionInfo{ApiIndex: 1, ID: 989, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlSampleCoveragex = builder.FunctionInfo{ApiIndex: 1, ID: 990, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlSampleCoveragexOES = builder.FunctionInfo{ApiIndex: 1, ID: 991, ReturnType: protocol.Type_Void, Parameters: 2}
var funcInfoGlScalef = builder.FunctionInfo{ApiIndex: 1, ID: 992, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlScalex = builder.FunctionInfo{ApiIndex: 1, ID: 993, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlScalexOES = builder.FunctionInfo{ApiIndex: 1, ID: 994, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlShadeModel = builder.FunctionInfo{ApiIndex: 1, ID: 995, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoGlTexCoordPointer = builder.FunctionInfo{ApiIndex: 1, ID: 996, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlTexEnvf = builder.FunctionInfo{ApiIndex: 1, ID: 997, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvfv = builder.FunctionInfo{ApiIndex: 1, ID: 998, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvi = builder.FunctionInfo{ApiIndex: 1, ID: 999, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnviv = builder.FunctionInfo{ApiIndex: 1, ID: 1000, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvx = builder.FunctionInfo{ApiIndex: 1, ID: 1001, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvxOES = builder.FunctionInfo{ApiIndex: 1, ID: 1002, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvxv = builder.FunctionInfo{ApiIndex: 1, ID: 1003, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexEnvxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 1004, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGenfOES = builder.FunctionInfo{ApiIndex: 1, ID: 1005, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGenfvOES = builder.FunctionInfo{ApiIndex: 1, ID: 1006, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGeniOES = builder.FunctionInfo{ApiIndex: 1, ID: 1007, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGenivOES = builder.FunctionInfo{ApiIndex: 1, ID: 1008, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGenxOES = builder.FunctionInfo{ApiIndex: 1, ID: 1009, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexGenxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 1010, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterx = builder.FunctionInfo{ApiIndex: 1, ID: 1011, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterxOES = builder.FunctionInfo{ApiIndex: 1, ID: 1012, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterxv = builder.FunctionInfo{ApiIndex: 1, ID: 1013, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTexParameterxvOES = builder.FunctionInfo{ApiIndex: 1, ID: 1014, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTranslatef = builder.FunctionInfo{ApiIndex: 1, ID: 1015, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTranslatex = builder.FunctionInfo{ApiIndex: 1, ID: 1016, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlTranslatexOES = builder.FunctionInfo{ApiIndex: 1, ID: 1017, ReturnType: protocol.Type_Void, Parameters: 3}
var funcInfoGlVertexPointer = builder.FunctionInfo{ApiIndex: 1, ID: 1018, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlWeightPointerOES = builder.FunctionInfo{ApiIndex: 1, ID: 1019, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlColorPointerBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1020, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlNormalPointerBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1021, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlTexCoordPointerBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1022, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlVertexPointerBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1023, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlPointSizePointerOESBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1024, ReturnType: protocol.Type_Void, Parameters: 4}
var funcInfoGlMatrixIndexPointerOESBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1025, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoGlWeightPointerOESBounds = builder.FunctionInfo{ApiIndex: 1, ID: 1026, ReturnType: protocol.Type_Void, Parameters: 5}
var funcInfoContextInfo = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1027, ReturnType: protocol.Type_Void, Parameters: 12}
var funcInfoReplayCreateRenderer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1028, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoReplayBindRenderer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1029, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoReplayChangeBackbuffer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1030, ReturnType: protocol.Type_Void, Parameters: 6}
var funcInfoStartTimer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1031, ReturnType: protocol.Type_Void, Parameters: 1}
var funcInfoStopTimer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1032, ReturnType: protocol.Type_Uint64, Parameters: 1}
var funcInfoFlushPostBuffer = builder.FunctionInfo{ApiIndex: 1, ID: 0x10000 - 1034 + 1033, ReturnType: protocol.Type_Void, Parameters: 0}
func (c EGLTimeKHR) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U64(uint64(c))
}
func (c DrawBufferIndex) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c VertexBufferBindingIndex) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c RenderbufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c TextureId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c FramebufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c BufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c ShaderId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c ProgramId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c VertexArrayId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c QueryId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c UniformLocation) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLint(c).value(ϟb, ϟa, ϟs)
}
func (c UniformIndex) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c AttributeLocation) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c AttributeIndex) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c SamplerId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c PipelineId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c UniformBlockId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c TransformFeedbackId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return GLuint(c).value(ϟb, ϟa, ϟs)
}
func (c ContextID) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c ThreadID) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U64(uint64(c))
}
func (c CGSWindowID) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c CGSSurfaceID) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLboolean) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U8(uint8(c))
}
func (c GLubyte) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U8(uint8(c))
}
func (c GLshort) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S16(int16(c))
}
func (c GLint) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLuint) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c GLint64) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c GLint64EXT) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c GLuint64) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U64(uint64(c))
}
func (c GLuint64EXT) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U64(uint64(c))
}
func (c GLfixed) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLsizei) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLintptr) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLsizeiptr) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c GLfloat) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.F32(float32(c))
}
func (c GLclampf) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.F32(float32(c))
}
func (c GLclampx) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c MsgID) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func subGetBoundBufferOrError(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum) (*Buffer, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return (*Buffer)(nil), ϟerr
}
id := func() (result BufferId) {
switch target {
case GLenum_GL_ARRAY_BUFFER:
return ctx.BoundBuffers.ArrayBuffer
case GLenum_GL_ELEMENT_ARRAY_BUFFER:
return ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer
case GLenum_GL_COPY_READ_BUFFER:
return ctx.BoundBuffers.CopyReadBuffer
case GLenum_GL_COPY_WRITE_BUFFER:
return ctx.BoundBuffers.CopyWriteBuffer
case GLenum_GL_PIXEL_PACK_BUFFER:
return ctx.BoundBuffers.PixelPackBuffer
case GLenum_GL_PIXEL_UNPACK_BUFFER:
return ctx.BoundBuffers.PixelUnpackBuffer
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER:
return ctx.BoundBuffers.TransformFeedbackBuffer
case GLenum_GL_UNIFORM_BUFFER:
return ctx.BoundBuffers.UniformBuffer
case GLenum_GL_ATOMIC_COUNTER_BUFFER:
return ctx.BoundBuffers.AtomicCounterBuffer
case GLenum_GL_DISPATCH_INDIRECT_BUFFER:
return ctx.BoundBuffers.DispatchIndirectBuffer
case GLenum_GL_DRAW_INDIRECT_BUFFER:
return ctx.BoundBuffers.DrawIndirectBuffer
case GLenum_GL_SHADER_STORAGE_BUFFER:
return ctx.BoundBuffers.ShaderStorageBuffer
case GLenum_GL_TEXTURE_BUFFER:
return ctx.BoundBuffers.TextureBuffer
default:
return BufferId(uint32(0))
}
}()
if (id) == (BufferId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return (*Buffer)(nil), ϟerr
}
}
return ctx.Instances.Buffers.Get(id), nil
}
func subBindBufferRange(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, index GLuint, buffer BufferId, offset GLintptr, size GLsizeiptr) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
bufferBinding := BufferBinding{Binding: buffer, Start: offset, Size: size}
switch target {
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.TransformFeedbackBuffer = buffer
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_0.Buffers[index] = bufferBinding
case GLenum_GL_UNIFORM_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.UniformBuffer = buffer
ctx.BoundBuffers.UniformBuffers[index] = bufferBinding
case GLenum_GL_ATOMIC_COUNTER_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.AtomicCounterBuffer = buffer
ctx.BoundBuffers.AtomicCounterBuffers[index] = bufferBinding
case GLenum_GL_SHADER_STORAGE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.ShaderStorageBuffer = buffer
ctx.BoundBuffers.ShaderStorageBuffers[index] = bufferBinding
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
if !(ctx.Instances.Buffers.Contains(buffer)) {
ctx.Instances.Buffers[buffer] = &Buffer{Size: GLsizeiptr(int32(0)), Usage: GLenum_GL_STATIC_DRAW, Mapped: GLboolean_GL_FALSE, MapPointer: U8ᵖ{}, MapOffset: GLintptr(int32(0)), MapLength: GLsizeiptr(int32(0))}
}
return nil
}
func subCopyBufferSubData(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, readTarget GLenum, writeTarget GLenum, readOffset GLintptr, writeOffset GLintptr, size GLsizeiptr) error {
_res_0, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, readTarget)
if ϟerr != nil {
return ϟerr
}
_ = _res_0
_res_1, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, writeTarget)
if ϟerr != nil {
return ϟerr
}
_ = _res_1
_ = readOffset
_ = writeOffset
_ = size
return nil
}
func subGetBufferPointerv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params Voidᵖᵖ) error {
switch target {
case GLenum_GL_ARRAY_BUFFER, GLenum_GL_COPY_READ_BUFFER, GLenum_GL_COPY_WRITE_BUFFER, GLenum_GL_ELEMENT_ARRAY_BUFFER, GLenum_GL_PIXEL_PACK_BUFFER, GLenum_GL_PIXEL_UNPACK_BUFFER, GLenum_GL_TRANSFORM_FEEDBACK_BUFFER, GLenum_GL_UNIFORM_BUFFER:
case GLenum_GL_ATOMIC_COUNTER_BUFFER, GLenum_GL_DISPATCH_INDIRECT_BUFFER, GLenum_GL_DRAW_INDIRECT_BUFFER, GLenum_GL_SHADER_STORAGE_BUFFER, GLenum_GL_TEXTURE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch pname {
case GLenum_GL_BUFFER_MAP_POINTER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
params.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subMapBuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, access GLenum, ptr U8ᵖ) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
accessBits := func() (result GLbitfield) {
switch access {
case GLenum_GL_READ_ONLY:
return GLbitfield_GL_MAP_READ_BIT
case GLenum_GL_WRITE_ONLY:
return GLbitfield_GL_MAP_WRITE_BIT
case GLenum_GL_READ_WRITE:
return (GLbitfield_GL_MAP_READ_BIT) | (GLbitfield_GL_MAP_WRITE_BIT)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", access, ϟa))
return result
}
}()
if ϟerr := subMapBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, GLintptr(int32(0)), b.Size, accessBits, ptr); ϟerr != nil {
return ϟerr
}
return nil
}
func subMapBufferRange(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, offset GLintptr, length GLsizeiptr, access GLbitfield, ptr U8ᵖ) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
if ((offset) < (GLintptr(int32(0)))) || (((length) < (GLsizeiptr(int32(0)))) || (((GLsizeiptr(offset)) + (length)) > (b.Size))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, access, (GLbitfield_GL_MAP_FLUSH_EXPLICIT_BIT)|((GLbitfield_GL_MAP_INVALIDATE_BUFFER_BIT)|((GLbitfield_GL_MAP_INVALIDATE_RANGE_BIT)|((GLbitfield_GL_MAP_READ_BIT)|((GLbitfield_GL_MAP_UNSYNCHRONIZED_BIT)|(GLbitfield_GL_MAP_WRITE_BIT)))))); ϟerr != nil {
return ϟerr
}
if (b.Mapped) == (GLboolean_GL_TRUE) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
b.Mapped = GLboolean_GL_TRUE
b.AccessFlags = access
b.MapPointer = ptr
b.MapOffset = offset
b.MapLength = length
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.mapMemory(ptr.Slice(uint64(GLsizeiptr(int32(0))), uint64(length), ϟs)))
if (GLbitfield_GL_MAP_READ_BIT)&(access) != 0 {
ptr.Slice(uint64(GLsizeiptr(int32(0))), uint64(length), ϟs).Copy(ϟctx, b.Data.Slice(uint64(offset), uint64((offset)+(GLintptr(length))), ϟs), ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subUnmapBuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
if (b.Mapped) == (GLboolean_GL_FALSE) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ((GLbitfield_GL_MAP_WRITE_BIT)&(b.AccessFlags) != 0) && (!((GLbitfield_GL_MAP_FLUSH_EXPLICIT_BIT)&(b.AccessFlags) != 0)) {
copyLength := GLintptr(b.MapLength)
b.Data.Slice(uint64(b.MapOffset), uint64((b.MapOffset)+(copyLength)), ϟs).Copy(ϟctx, b.MapPointer.Slice(uint64(GLintptr(int32(0))), uint64(copyLength), ϟs), ϟa, ϟs, ϟd, ϟb)
}
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.unmapMemory(b.MapPointer.Slice(uint64(GLsizeiptr(int32(0))), uint64(b.MapLength), ϟs)))
b.Mapped = GLboolean_GL_FALSE
b.AccessFlags = GLbitfield(int32(0))
b.MapPointer = U8ᵖ{}
b.MapOffset = GLintptr(int32(0))
b.MapLength = GLsizeiptr(int32(0))
return nil
}
func subFlushMappedBufferRange(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, offset GLintptr, length GLsizeiptr) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
if (b.Mapped) == (GLboolean_GL_FALSE) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if !((GLbitfield_GL_MAP_FLUSH_EXPLICIT_BIT)&(b.AccessFlags) != 0) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ((offset) < (GLintptr(int32(0)))) || (((length) < (GLsizeiptr(int32(0)))) || (((GLsizeiptr(offset)) + (length)) > (b.MapLength))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
dstOffset := (b.MapOffset) + (offset)
b.Data.Slice(uint64(dstOffset), uint64((dstOffset)+(GLintptr(length))), ϟs).Copy(ϟctx, b.MapPointer.Slice(uint64(offset), uint64((offset)+(GLintptr(length))), ϟs), ϟa, ϟs, ϟd, ϟb)
return nil
}
func subSetConstant(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *StaticContextState, name GLenum, value U8ˢ) error {
switch name {
case GLenum_GL_RENDERER:
ctx.Constants.Renderer = string(gfxapi.CharToBytes(AsCharˢ(value, ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
case GLenum_GL_VENDOR:
ctx.Constants.Vendor = string(gfxapi.CharToBytes(AsCharˢ(value, ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
case GLenum_GL_VERSION:
ctx.Constants.Version = string(gfxapi.CharToBytes(AsCharˢ(value, ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
case GLenum_GL_EXTENSIONS:
extensions := AsCharˢ(value, ϟs)
for start := int32(0); start < int32(value.Count); start++ {
if ((start) == (int32(0))) || ((string(gfxapi.CharToBytes(extensions.Slice(uint64((start)-(int32(1))), uint64(start), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))) == (" ")) {
idx := uint32(len(ctx.Constants.Extensions))
for end := start; end < (int32(value.Count))+(int32(1)); end++ {
if ((end) == (int32(value.Count))) || ((string(gfxapi.CharToBytes(extensions.Slice(uint64(end), uint64((end)+(int32(1))), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))) == (" ")) {
if !(ctx.Constants.Extensions.Contains(idx)) {
ctx.Constants.Extensions[idx] = string(gfxapi.CharToBytes(extensions.Slice(uint64(start), uint64(end), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
}
}
}
}
}
case GLenum_GL_SHADING_LANGUAGE_VERSION:
ctx.Constants.ShadingLanguageVersion = string(gfxapi.CharToBytes(AsCharˢ(value, ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
case GLenum_GL_SUBPIXEL_BITS:
ctx.Constants.SubpixelBits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENT_INDEX:
ctx.Constants.MaxElementIndex = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_3D_TEXTURE_SIZE:
ctx.Constants.Max3dTextureSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_SIZE:
ctx.Constants.MaxTextureSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ARRAY_TEXTURE_LAYERS:
ctx.Constants.MaxArrayTextureLayers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_LOD_BIAS:
ctx.Constants.MaxTextureLodBias = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
ctx.Constants.MaxCubeMapTextureSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_RENDERBUFFER_SIZE:
ctx.Constants.MaxRenderbufferSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_POINT_SIZE_RANGE:
ctx.Constants.AliasedPointSizeRange.Elements[uint64(0)] = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.AliasedPointSizeRange.Elements[uint64(1)] = AsGLfloatˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_LINE_WIDTH_RANGE:
ctx.Constants.AliasedLineWidthRange.Elements[uint64(0)] = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.AliasedLineWidthRange.Elements[uint64(1)] = AsGLfloatˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_RANGE:
ctx.Constants.MultisampleLineWidthRange.Elements[uint64(0)] = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MultisampleLineWidthRange.Elements[uint64(1)] = AsGLfloatˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY:
ctx.Constants.MultisampleLineWidthGranularity = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DRAW_BUFFERS:
ctx.Constants.MaxDrawBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_WIDTH:
ctx.Constants.MaxFramebufferWidth = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_HEIGHT:
ctx.Constants.MaxFramebufferHeight = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_LAYERS:
ctx.Constants.MaxFramebufferLayers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_SAMPLES:
ctx.Constants.MaxFramebufferSamples = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_ATTACHMENTS:
ctx.Constants.MaxColorAttachments = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
ctx.Constants.MinFragmentInterpolationOffset = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
ctx.Constants.MaxFragmentInterpolationOffset = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
ctx.Constants.FragmentInterpolationOffsetBits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VIEWPORT_DIMS:
ctx.Constants.MaxViewportDims.Elements[uint64(0)] = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MaxViewportDims.Elements[uint64(1)] = AsGLintˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLE_MASK_WORDS:
ctx.Constants.MaxSampleMaskWords = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_TEXTURE_SAMPLES:
ctx.Constants.MaxColorTextureSamples = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEPTH_TEXTURE_SAMPLES:
ctx.Constants.MaxDepthTextureSamples = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_INTEGER_SAMPLES:
ctx.Constants.MaxIntegerSamples = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SERVER_WAIT_TIMEOUT:
ctx.Constants.MaxServerWaitTimeout = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LAYER_PROVOKING_VERTEX:
ctx.Constants.LayerProvokingVertex = AsGLenumˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED:
ctx.Constants.PrimitiveRestartForPatchesSupported = AsGLbooleanˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
ctx.Constants.MaxVertexAttribRelativeOffset = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_BINDINGS:
ctx.Constants.MaxVertexAttribBindings = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_STRIDE:
ctx.Constants.MaxVertexAttribStride = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_INDICES:
ctx.Constants.MaxElementsIndices = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_VERTICES:
ctx.Constants.MaxElementsVertices = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_BUFFER_SIZE:
ctx.Constants.MaxTextureBufferSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COMPRESSED_TEXTURE_FORMATS:
formats := AsGLenumˢ(value, ϟs)
for i := uint32(0); i < uint32(formats.Count); i++ {
ctx.Constants.CompressedTextureFormats[i] = formats.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_PROGRAM_BINARY_FORMATS:
formats := AsGLenumˢ(value, ϟs)
for i := uint32(0); i < uint32(formats.Count); i++ {
ctx.Constants.ProgramBinaryFormats[i] = formats.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_BINARY_FORMATS:
formats := AsGLenumˢ(value, ϟs)
for i := uint32(0); i < uint32(formats.Count); i++ {
ctx.Constants.ShaderBinaryFormats[i] = formats.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_COMPILER:
ctx.Constants.ShaderCompiler = AsGLbooleanˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
ctx.Constants.TextureBufferOffsetAlignment = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAJOR_VERSION:
ctx.Constants.MajorVersion = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MINOR_VERSION:
ctx.Constants.MinorVersion = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CONTEXT_FLAGS:
ctx.Constants.ContextFlags = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIBS:
ctx.Constants.MaxVertexAttribs = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_COMPONENTS:
ctx.Constants.MaxVertexUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_VECTORS:
ctx.Constants.MaxVertexUniformVectors = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_BLOCKS:
ctx.Constants.MaxVertexUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_OUTPUT_COMPONENTS:
ctx.Constants.MaxVertexOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxVertexTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxVertexAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTERS:
ctx.Constants.MaxVertexAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxVertexShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_GEN_LEVEL:
ctx.Constants.MaxTessGenLevel = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PATCH_VERTICES:
ctx.Constants.MaxPatchVertices = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:
ctx.Constants.MaxTessControlUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxTessControlTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:
ctx.Constants.MaxTessControlOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_PATCH_COMPONENTS:
ctx.Constants.MaxTessPatchComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:
ctx.Constants.MaxTessControlTotalOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:
ctx.Constants.MaxTessControlInputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:
ctx.Constants.MaxTessControlUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxTessControlAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
ctx.Constants.MaxTessControlAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxTessControlShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS:
ctx.Constants.MaxTessEvaluationUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxTessEvaluationTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS:
ctx.Constants.MaxTessEvaluationOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS:
ctx.Constants.MaxTessEvaluationInputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS:
ctx.Constants.MaxTessEvaluationUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxTessEvaluationAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
ctx.Constants.MaxTessEvaluationAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxTessEvaluationShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
ctx.Constants.MaxGeometryUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
ctx.Constants.MaxGeometryUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_INPUT_COMPONENTS:
ctx.Constants.MaxGeometryInputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:
ctx.Constants.MaxGeometryOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_VERTICES:
ctx.Constants.MaxGeometryOutputVertices = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
ctx.Constants.MaxGeometryTotalOutputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxGeometryTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
ctx.Constants.MaxGeometryShaderInvocations = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxGeometryAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
ctx.Constants.MaxGeometryAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxGeometryShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
ctx.Constants.MaxFragmentUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
ctx.Constants.MaxFragmentUniformVectors = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
ctx.Constants.MaxFragmentUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INPUT_COMPONENTS:
ctx.Constants.MaxFragmentInputComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxFragmentAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
ctx.Constants.MaxFragmentAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxFragmentShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
ctx.Constants.MinProgramTextureGatherOffset = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
ctx.Constants.MaxProgramTextureGatherOffset = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXEL_OFFSET:
ctx.Constants.MinProgramTexelOffset = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXEL_OFFSET:
ctx.Constants.MaxProgramTexelOffset = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_COUNT:
ctx.Constants.MaxComputeWorkGroupCount.Elements[uint64(0)] = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MaxComputeWorkGroupCount.Elements[uint64(1)] = AsGLintˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MaxComputeWorkGroupCount.Elements[uint64(2)] = AsGLintˢ(value, ϟs).Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_SIZE:
ctx.Constants.MaxComputeWorkGroupSize.Elements[uint64(0)] = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MaxComputeWorkGroupSize.Elements[uint64(1)] = AsGLintˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
ctx.Constants.MaxComputeWorkGroupSize.Elements[uint64(2)] = AsGLintˢ(value, ϟs).Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
ctx.Constants.MaxComputeWorkGroupInvocations = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_BLOCKS:
ctx.Constants.MaxComputeUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxComputeTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
ctx.Constants.MaxComputeSharedMemorySize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
ctx.Constants.MaxComputeUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxComputeAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTERS:
ctx.Constants.MaxComputeAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedComputeUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxComputeShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BUFFER_BINDINGS:
ctx.Constants.MaxUniformBufferBindings = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BLOCK_SIZE:
ctx.Constants.MaxUniformBlockSize = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
ctx.Constants.UniformBufferOffsetAlignment = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_UNIFORM_BLOCKS:
ctx.Constants.MaxCombinedUniformBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedVertexUniformComponents = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedTessControlUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedTessEvaluationUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedGeometryUniformComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
ctx.Constants.MaxCombinedFragmentUniformComponents = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_COMPONENTS:
ctx.Constants.MaxVaryingComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_VECTORS:
ctx.Constants.MaxVaryingVectors = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
ctx.Constants.MaxCombinedTextureImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
ctx.Constants.MaxCombinedShaderOutputResources = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_LOCATIONS:
ctx.Constants.MaxUniformLocations = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
ctx.Constants.MaxAtomicCounterBufferBindings = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
ctx.Constants.MaxAtomicCounterBufferSize = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
ctx.Constants.MaxCombinedAtomicCounterBuffers = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTERS:
ctx.Constants.MaxCombinedAtomicCounters = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_IMAGE_UNITS:
ctx.Constants.MaxImageUnits = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_IMAGE_UNIFORMS:
ctx.Constants.MaxVertexImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
ctx.Constants.MaxTessControlImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS:
ctx.Constants.MaxTessEvaluationImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_IMAGE_UNIFORMS:
ctx.Constants.MaxGeometryImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
ctx.Constants.MaxFragmentImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_IMAGE_UNIFORMS:
ctx.Constants.MaxComputeImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_IMAGE_UNIFORMS:
ctx.Constants.MaxCombinedImageUniforms = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
ctx.Constants.MaxShaderStorageBufferBindings = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
ctx.Constants.MaxShaderStorageBlockSize = AsGLint64ˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
ctx.Constants.MaxCombinedShaderStorageBlocks = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
ctx.Constants.ShaderStorageBufferOffsetAlignment = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_MESSAGE_LENGTH:
ctx.Constants.MaxDebugMessageLength = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_LOGGED_MESSAGES:
ctx.Constants.MaxDebugLoggedMessages = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_GROUP_STACK_DEPTH:
ctx.Constants.MaxDebugGroupStackDepth = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_LABEL_LENGTH:
ctx.Constants.MaxLabelLength = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
ctx.Constants.MaxTransformFeedbackInterleavedComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
ctx.Constants.MaxTransformFeedbackSeparateAttribs = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
ctx.Constants.MaxTransformFeedbackSeparateComponents = AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
ctx.Constants.MaxTextureMaxAnisotropyExt = AsGLfloatˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LOW_FLOAT, GLenum_GL_MEDIUM_FLOAT, GLenum_GL_HIGH_FLOAT, GLenum_GL_LOW_INT, GLenum_GL_MEDIUM_INT, GLenum_GL_HIGH_INT:
vsPrecisionFormat := PrecisionFormat{MinRange: AsGLintˢ(value, ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), MaxRange: AsGLintˢ(value, ϟs).Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), Precision: AsGLintˢ(value, ϟs).Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)}
fsPrecisionFormat := PrecisionFormat{MinRange: AsGLintˢ(value, ϟs).Index(uint64(3), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), MaxRange: AsGLintˢ(value, ϟs).Index(uint64(4), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), Precision: AsGLintˢ(value, ϟs).Index(uint64(5), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)}
switch name {
case GLenum_GL_LOW_FLOAT:
ctx.Constants.VertexShaderPrecisionFormat.LowFloat = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.LowFloat = fsPrecisionFormat
case GLenum_GL_MEDIUM_FLOAT:
ctx.Constants.VertexShaderPrecisionFormat.MediumFloat = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.MediumFloat = fsPrecisionFormat
case GLenum_GL_HIGH_FLOAT:
ctx.Constants.VertexShaderPrecisionFormat.HighFloat = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.HighFloat = fsPrecisionFormat
case GLenum_GL_LOW_INT:
ctx.Constants.VertexShaderPrecisionFormat.LowInt = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.LowInt = fsPrecisionFormat
case GLenum_GL_MEDIUM_INT:
ctx.Constants.VertexShaderPrecisionFormat.MediumInt = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.MediumInt = fsPrecisionFormat
case GLenum_GL_HIGH_INT:
ctx.Constants.VertexShaderPrecisionFormat.HighInt = vsPrecisionFormat
ctx.Constants.FragmentShaderPrecisionFormat.HighInt = fsPrecisionFormat
default:
v := name
return fmt.Errorf("Missing switch case handler for value %T %v", v, v)
}
default:
}
return nil
}
func subDebugMessageCallback(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, callback GLDEBUGPROC, userParam Voidᶜᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Debug.CallbackFunction = callback
ctx.Debug.CallbackUserParam = userParam
return nil
}
func subDebugMessageControl(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, source GLenum, ty GLenum, severity GLenum, count GLsizei, ids GLuintᶜᵖ, enabled GLboolean) error {
switch source {
case GLenum_GL_DEBUG_SOURCE_API, GLenum_GL_DEBUG_SOURCE_APPLICATION, GLenum_GL_DEBUG_SOURCE_OTHER, GLenum_GL_DEBUG_SOURCE_SHADER_COMPILER, GLenum_GL_DEBUG_SOURCE_THIRD_PARTY, GLenum_GL_DEBUG_SOURCE_WINDOW_SYSTEM, GLenum_GL_DONT_CARE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, source); ϟerr != nil {
return ϟerr
}
}
switch ty {
case GLenum_GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, GLenum_GL_DEBUG_TYPE_ERROR, GLenum_GL_DEBUG_TYPE_MARKER, GLenum_GL_DEBUG_TYPE_OTHER, GLenum_GL_DEBUG_TYPE_PERFORMANCE, GLenum_GL_DEBUG_TYPE_POP_GROUP, GLenum_GL_DEBUG_TYPE_PORTABILITY, GLenum_GL_DEBUG_TYPE_PUSH_GROUP, GLenum_GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, GLenum_GL_DONT_CARE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
switch severity {
case GLenum_GL_DEBUG_SEVERITY_HIGH, GLenum_GL_DEBUG_SEVERITY_LOW, GLenum_GL_DEBUG_SEVERITY_MEDIUM, GLenum_GL_DEBUG_SEVERITY_NOTIFICATION, GLenum_GL_DONT_CARE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, severity); ϟerr != nil {
return ϟerr
}
}
_ = enabled
ids.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subDebugMessageInsert(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, source GLenum, ty GLenum, id GLuint, severity GLenum, length GLsizei, message GLcharᶜᵖ) error {
switch source {
case GLenum_GL_DEBUG_SOURCE_APPLICATION, GLenum_GL_DEBUG_SOURCE_THIRD_PARTY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, source); ϟerr != nil {
return ϟerr
}
}
switch ty {
case GLenum_GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, GLenum_GL_DEBUG_TYPE_ERROR, GLenum_GL_DEBUG_TYPE_MARKER, GLenum_GL_DEBUG_TYPE_OTHER, GLenum_GL_DEBUG_TYPE_PERFORMANCE, GLenum_GL_DEBUG_TYPE_POP_GROUP, GLenum_GL_DEBUG_TYPE_PORTABILITY, GLenum_GL_DEBUG_TYPE_PUSH_GROUP, GLenum_GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
switch severity {
case GLenum_GL_DEBUG_SEVERITY_HIGH, GLenum_GL_DEBUG_SEVERITY_LOW, GLenum_GL_DEBUG_SEVERITY_MEDIUM, GLenum_GL_DEBUG_SEVERITY_NOTIFICATION:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, severity); ϟerr != nil {
return ϟerr
}
}
_ = id
if ϟerr := subReadString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, length, message); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetDebugMessageLog(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, count GLuint, bufSize GLsizei, sources GLenumᵖ, types GLenumᵖ, ids GLuintᵖ, severities GLenumᵖ, lengths GLsizeiᵖ, messageLog GLcharᵖ, gotCount GLuint) error {
_ = count
if (sources) != (GLenumᵖ{}) {
sources.Slice(uint64(GLuint(uint32(0))), uint64(gotCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if (types) != (GLenumᵖ{}) {
types.Slice(uint64(GLuint(uint32(0))), uint64(gotCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if (ids) != (GLuintᵖ{}) {
ids.Slice(uint64(GLuint(uint32(0))), uint64(gotCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if (severities) != (GLenumᵖ{}) {
severities.Slice(uint64(GLuint(uint32(0))), uint64(gotCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if (lengths) != (GLsizeiᵖ{}) {
lengths.Slice(uint64(GLuint(uint32(0))), uint64(gotCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if (gotCount) > (GLuint(uint32(0))) {
messageLog.Slice(uint64(GLsizei(int32(0))), uint64(bufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subGetObjectLabel(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, identifier GLenum, name GLuint, bufSize GLsizei, length GLsizeiᵖ, label GLcharᵖ) error {
switch identifier {
case GLenum_GL_BUFFER, GLenum_GL_FRAMEBUFFER, GLenum_GL_PROGRAM, GLenum_GL_PROGRAM_PIPELINE, GLenum_GL_QUERY, GLenum_GL_RENDERBUFFER, GLenum_GL_SAMPLER, GLenum_GL_SHADER, GLenum_GL_TEXTURE, GLenum_GL_TRANSFORM_FEEDBACK, GLenum_GL_VERTEX_ARRAY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, identifier); ϟerr != nil {
return ϟerr
}
}
_ = name
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, bufSize, length, label); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetObjectPtrLabel(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ptr Voidᶜᵖ, bufSize GLsizei, length GLsizeiᵖ, label GLcharᵖ) error {
_ = ptr
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, bufSize, length, label); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetPointerv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, pname GLenum, params Voidᵖᵖ) error {
switch pname {
case GLenum_GL_DEBUG_CALLBACK_FUNCTION, GLenum_GL_DEBUG_CALLBACK_USER_PARAM:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
params.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subObjectLabel(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, identifier GLenum, name GLuint, length GLsizei, label GLcharᶜᵖ) error {
str := func() (result string) {
switch (label) != (GLcharᶜᵖ{}) {
case true:
return func() (result string) {
switch (length) < (GLsizei(int32(0))) {
case true:
return strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(label).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
case false:
return string(gfxapi.CharToBytes(AsCharˢ(label.Slice(uint64(GLsizei(int32(0))), uint64(length), ϟs), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (length) < (GLsizei(int32(0))), ϟa))
return result
}
}()
case false:
return ""
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (label) != (GLcharᶜᵖ{}), ϟa))
return result
}
}()
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch identifier {
case GLenum_GL_TEXTURE:
if !(ctx.Instances.Textures.Contains(TextureId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Textures.Get(TextureId(name)).OnAccess(ϟs).Label = str
case GLenum_GL_FRAMEBUFFER:
if !(ctx.Instances.Framebuffers.Contains(FramebufferId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Framebuffers.Get(FramebufferId(name)).Label = str
case GLenum_GL_RENDERBUFFER:
if !(ctx.Instances.Renderbuffers.Contains(RenderbufferId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Renderbuffers.Get(RenderbufferId(name)).Label = str
case GLenum_GL_BUFFER:
if !(ctx.Instances.Buffers.Contains(BufferId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Buffers.Get(BufferId(name)).Label = str
case GLenum_GL_SHADER:
if !(ctx.Instances.Shaders.Contains(ShaderId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Shaders.Get(ShaderId(name)).OnAccess(ϟs).Label = str
case GLenum_GL_PROGRAM:
if !(ctx.Instances.Programs.Contains(ProgramId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Programs.Get(ProgramId(name)).OnAccess(ϟs).Label = str
case GLenum_GL_VERTEX_ARRAY:
if !(ctx.Instances.VertexArrays.Contains(VertexArrayId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.VertexArrays.Get(VertexArrayId(name)).Label = str
case GLenum_GL_QUERY:
if !(ctx.Instances.Queries.Contains(QueryId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Queries.Get(QueryId(name)).Label = str
case GLenum_GL_SAMPLER:
if !(ctx.Instances.Samplers.Contains(SamplerId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Samplers.Get(SamplerId(name)).Label = str
case GLenum_GL_TRANSFORM_FEEDBACK:
if !(ctx.Instances.TransformFeedbacks.Contains(TransformFeedbackId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.TransformFeedbacks.Get(TransformFeedbackId(name)).Label = str
case GLenum_GL_PROGRAM_PIPELINE:
if !(ctx.Instances.Pipelines.Contains(PipelineId(name))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Pipelines.Get(PipelineId(name)).Label = str
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, identifier); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subObjectPtrLabel(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ptr Voidᶜᵖ, length GLsizei, label GLcharᶜᵖ) error {
_ = ptr
if ϟerr := subReadString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, length, label); ϟerr != nil {
return ϟerr
}
return nil
}
func subPopDebugGroup(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
return nil
}
func subPushDebugGroup(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, source GLenum, id GLuint, length GLsizei, message GLcharᶜᵖ) error {
switch source {
case GLenum_GL_DEBUG_SOURCE_APPLICATION, GLenum_GL_DEBUG_SOURCE_THIRD_PARTY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, source); ϟerr != nil {
return ϟerr
}
}
_ = id
if ϟerr := subReadString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, length, message); ϟerr != nil {
return ϟerr
}
return nil
}
func subCheckPrimitiveType(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum) error {
switch drawmode {
case GLenum_GL_LINES, GLenum_GL_LINE_LOOP, GLenum_GL_LINE_STRIP, GLenum_GL_POINTS, GLenum_GL_TRIANGLES, GLenum_GL_TRIANGLE_FAN, GLenum_GL_TRIANGLE_STRIP:
case GLenum_GL_LINES_ADJACENCY, GLenum_GL_LINE_STRIP_ADJACENCY, GLenum_GL_PATCHES, GLenum_GL_TRIANGLES_ADJACENCY, GLenum_GL_TRIANGLE_STRIP_ADJACENCY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, drawmode); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subCheckIndicesType(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, indicestype GLenum) error {
switch indicestype {
case GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_SHORT:
case GLenum_GL_UNSIGNED_INT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, indicestype); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subDrawArraysInstanced(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum, firstindex GLint, indicescount GLsizei, instancecount GLsizei) error {
if ϟerr := subCheckPrimitiveType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, drawmode); ϟerr != nil {
return ϟerr
}
if (firstindex) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (indicescount) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (instancecount) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subReadVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, uint32(firstindex), uint32(indicescount), uint32(instancecount)); ϟerr != nil {
return ϟerr
}
return nil
}
func subDrawElements(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, drawmode GLenum, indicescount GLsizei, indicestype GLenum, indices IndicesPointer, instancecount GLsizei, basevertex GLint) error {
if ϟerr := subCheckPrimitiveType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, drawmode); ϟerr != nil {
return ϟerr
}
if (indicescount) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subCheckIndicesType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, indicestype); ϟerr != nil {
return ϟerr
}
if (instancecount) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (indicescount) > (GLsizei(int32(0))) {
count := uint32(indicescount)
id := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer
if (id) != (BufferId(uint32(0))) {
index_data := ctx.Instances.Buffers.Get(id).Data
offset := uint32(uint64(indices.Address))
limits := (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.IndexLimits(U8ᵖ(index_data.Index(0, ϟs)), indicestype, offset, count))
if ϟerr := subReadVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, (limits.First)+(uint32(basevertex)), ((limits.Last)-(limits.First))+(uint32(1)), uint32(instancecount)); ϟerr != nil {
return ϟerr
}
} else {
index_data := U8ᵖ(indices)
limits := (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.IndexLimits(index_data, indicestype, uint32(0), count))
if ϟerr := subReadVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, (limits.First)+(uint32(basevertex)), ((limits.Last)-(limits.First))+(uint32(1)), uint32(instancecount)); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIndexSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, indicestype)
if ϟerr != nil {
return ϟerr
}
index_data.Slice(uint64(uint32(0)), uint64((count)*(_res_0)), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
}
return nil
}
func subDrawElementsBaseVertex(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum, indicescount GLsizei, indicestype GLenum, indices IndicesPointer, basevertex GLint) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, drawmode, indicescount, indicestype, indices, GLsizei(int32(1)), basevertex); ϟerr != nil {
return ϟerr
}
return nil
}
func subDrawElementsInstanced(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum, indicescount GLsizei, indicestype GLenum, indices IndicesPointer, instancecount GLsizei) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, drawmode, indicescount, indicestype, indices, instancecount, GLint(int32(0))); ϟerr != nil {
return ϟerr
}
return nil
}
func subDrawElementsInstancedBaseVertex(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum, indicescount GLsizei, indicestype GLenum, indices IndicesPointer, instancecount GLsizei, basevertex GLint) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, drawmode, indicescount, indicestype, indices, instancecount, basevertex); ϟerr != nil {
return ϟerr
}
return nil
}
func subDrawRangeElementsBaseVertex(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, drawmode GLenum, start GLuint, end GLuint, indicescount GLsizei, indicestype GLenum, indices IndicesPointer, basevertex GLint) error {
if (end) < (start) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, drawmode, indicescount, indicestype, indices, GLsizei(int32(1)), basevertex); ϟerr != nil {
return ϟerr
}
return nil
}
func subPatchParameteri(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, pname GLenum, value GLint) error {
if (pname) != (GLenum_GL_PATCH_VERTICES) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Miscellaneous.PatchVertices = value
return nil
}
func subPrimitiveBoundingBox(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, minX GLfloat, minY GLfloat, minZ GLfloat, minW GLfloat, maxX GLfloat, maxY GLfloat, maxZ GLfloat, maxW GLfloat) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.PrimitiveBoundingBox.Min = Vec4f{Elements: [4]GLfloat{minX, minY, minZ, minW}}
ctx.Rasterization.PrimitiveBoundingBox.Max = Vec4f{Elements: [4]GLfloat{maxX, maxY, maxZ, maxW}}
return nil
}
func subObserveAttribList(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, attriblist EGLintᶜᵖ) error {
if (attriblist) != (EGLintᶜᵖ{}) {
done := MakeBoolˢ(uint64(1), ϟs)
done.Index(uint64(0), ϟs).Write(ϟctx, false, ϟa, ϟs, ϟd, ϟb)
for i := int32(0); i < int32(256); i++ {
if !(done.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)) {
pair := attriblist.Slice(uint64((i)*(int32(2))), uint64(((i)*(int32(2)))+(int32(2))), ϟs)
if (EGLenum(pair.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))) != (EGLenum_EGL_NONE) {
_ = pair.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
done.Index(uint64(0), ϟs).Write(ϟctx, true, ϟa, ϟs, ϟd, ϟb)
}
}
}
}
return nil
}
func subApplyProgramInfoExtra(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, programId ProgramId, info *ProgramInfo) error {
if (info) != ((*ProgramInfo)(nil)) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
program := ctx.Instances.Programs.Get(programId)
program.OnAccess(ϟs).LinkStatus = info.LinkStatus
program.OnAccess(ϟs).InfoLog = info.InfoLog
program.OnAccess(ϟs).ActiveAttributes = AttributeIndexːActiveAttributeᵐ{}
program.OnAccess(ϟs).ActiveUniforms = UniformIndexːActiveUniformᵐ{}
program.OnAccess(ϟs).Uniforms = UniformLocationːUniformᵐ{}
for i := AttributeIndex(uint32(0)); i < AttributeIndex(uint32(len(info.ActiveAttributes))); i++ {
program.OnAccess(ϟs).ActiveAttributes[i] = info.ActiveAttributes.Get(i)
}
for i := UniformIndex(uint32(0)); i < UniformIndex(uint32(len(info.ActiveUniforms))); i++ {
u := info.ActiveUniforms.Get(i)
program.OnAccess(ϟs).ActiveUniforms[i] = u
for j := UniformLocation(int32(0)); j < UniformLocation(u.ArraySize); j++ {
program.OnAccess(ϟs).Uniforms[(u.Location)+(j)] = Uniform{Value: MakeU8ˢ(uint64(0), ϟs), Type: u.Type}
}
}
}
return nil
}
func subBlendBarrier(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
return nil
}
func subBlendEquationSeparatei(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, buf DrawBufferIndex, modeRGB GLenum, modeAlpha GLenum) error {
if ϟerr := subSetBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, buf, int32(1), modeRGB, modeAlpha); ϟerr != nil {
return ϟerr
}
return nil
}
func subBlendEquationi(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, buf DrawBufferIndex, mode GLenum) error {
if ϟerr := subSetBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, buf, int32(1), mode, mode); ϟerr != nil {
return ϟerr
}
return nil
}
func subCheckBlendEquation(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, equation GLenum) error {
switch equation {
case GLenum_GL_FUNC_ADD, GLenum_GL_FUNC_REVERSE_SUBTRACT, GLenum_GL_FUNC_SUBTRACT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_MAX, GLenum_GL_MIN:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, equation); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSetBlendEquation(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, firstbuffer DrawBufferIndex, buffercount int32, rgb GLenum, alpha GLenum) error {
if ϟerr := subCheckBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, rgb); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, alpha); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := firstbuffer; i < (firstbuffer)+(DrawBufferIndex(buffercount)); i++ {
blend := ctx.FragmentOperations.Blend.Get(i)
blend.EquationRgb = rgb
blend.EquationAlpha = alpha
ctx.FragmentOperations.Blend[i] = blend
}
return nil
}
func subBlendFuncSeparatei(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, buf DrawBufferIndex, srcRGB GLenum, dstRGB GLenum, srcAlpha GLenum, dstAlpha GLenum) error {
if ϟerr := subSetBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, buf, int32(1), srcRGB, dstRGB, srcAlpha, dstAlpha); ϟerr != nil {
return ϟerr
}
return nil
}
func subBlendFunci(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, buf DrawBufferIndex, src GLenum, dst GLenum) error {
if ϟerr := subSetBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, buf, int32(1), src, dst, src, dst); ϟerr != nil {
return ϟerr
}
return nil
}
func subCheckBlendFunc(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, factor GLenum) error {
switch factor {
case GLenum_GL_CONSTANT_ALPHA, GLenum_GL_CONSTANT_COLOR, GLenum_GL_DST_ALPHA, GLenum_GL_DST_COLOR, GLenum_GL_ONE, GLenum_GL_ONE_MINUS_CONSTANT_ALPHA, GLenum_GL_ONE_MINUS_CONSTANT_COLOR, GLenum_GL_ONE_MINUS_DST_ALPHA, GLenum_GL_ONE_MINUS_DST_COLOR, GLenum_GL_ONE_MINUS_SRC_ALPHA, GLenum_GL_ONE_MINUS_SRC_COLOR, GLenum_GL_SRC_ALPHA, GLenum_GL_SRC_ALPHA_SATURATE, GLenum_GL_SRC_COLOR, GLenum_GL_ZERO:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, factor); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSetBlendFunc(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, firstbuffer DrawBufferIndex, buffercount int32, srcRgb GLenum, dstRgb GLenum, srcAlpha GLenum, dstAlpha GLenum) error {
if ϟerr := subCheckBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, srcRgb); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, dstRgb); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, srcAlpha); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, dstAlpha); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := firstbuffer; i < (firstbuffer)+(DrawBufferIndex(buffercount)); i++ {
blend := ctx.FragmentOperations.Blend.Get(i)
blend.SrcRgb = srcRgb
blend.DstRgb = dstRgb
blend.SrcAlpha = srcAlpha
blend.DstAlpha = dstAlpha
ctx.FragmentOperations.Blend[i] = blend
}
return nil
}
func subStencilFuncSeparate(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, face GLenum, function GLenum, referencevalue GLint, mask GLuint) error {
switch face {
case GLenum_GL_BACK, GLenum_GL_FRONT, GLenum_GL_FRONT_AND_BACK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, face); ϟerr != nil {
return ϟerr
}
}
switch function {
case GLenum_GL_ALWAYS, GLenum_GL_EQUAL, GLenum_GL_GEQUAL, GLenum_GL_GREATER, GLenum_GL_LEQUAL, GLenum_GL_LESS, GLenum_GL_NEVER, GLenum_GL_NOTEQUAL:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, function); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((face) == (GLenum_GL_FRONT)) || ((face) == (GLenum_GL_FRONT_AND_BACK)) {
ctx.FragmentOperations.Stencil.Func = function
ctx.FragmentOperations.Stencil.Ref = referencevalue
ctx.FragmentOperations.Stencil.ValueMask = mask
}
if ((face) == (GLenum_GL_BACK)) || ((face) == (GLenum_GL_FRONT_AND_BACK)) {
ctx.FragmentOperations.Stencil.BackFunc = function
ctx.FragmentOperations.Stencil.BackRef = referencevalue
ctx.FragmentOperations.Stencil.BackValueMask = mask
}
return nil
}
func subCheckStencilOp(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, op GLenum) error {
switch op {
case GLenum_GL_DECR, GLenum_GL_DECR_WRAP, GLenum_GL_INCR, GLenum_GL_INCR_WRAP, GLenum_GL_INVERT, GLenum_GL_KEEP, GLenum_GL_REPLACE, GLenum_GL_ZERO:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, op); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subStencilOpSeparate(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, face GLenum, fail GLenum, passdepthfail GLenum, passdepthpass GLenum) error {
switch face {
case GLenum_GL_BACK, GLenum_GL_FRONT, GLenum_GL_FRONT_AND_BACK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, face); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subCheckStencilOp(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, fail); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckStencilOp(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, passdepthfail); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckStencilOp(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, passdepthpass); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((face) == (GLenum_GL_FRONT)) || ((face) == (GLenum_GL_FRONT_AND_BACK)) {
ctx.FragmentOperations.Stencil.Fail = fail
ctx.FragmentOperations.Stencil.PassDepthFail = passdepthfail
ctx.FragmentOperations.Stencil.PassDepthPass = passdepthpass
}
if ((face) == (GLenum_GL_BACK)) || ((face) == (GLenum_GL_FRONT_AND_BACK)) {
ctx.FragmentOperations.Stencil.BackFail = fail
ctx.FragmentOperations.Stencil.BackPassDepthFail = passdepthfail
ctx.FragmentOperations.Stencil.BackPassDepthPass = passdepthpass
}
return nil
}
func subGetBoundFramebufferOrErrorInvalidEnum(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, framebuffertarget GLenum) (*Framebuffer, error) {
switch framebuffertarget {
case GLenum_GL_FRAMEBUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return (*Framebuffer)(nil), ϟerr
}
case GLenum_GL_DRAW_FRAMEBUFFER, GLenum_GL_READ_FRAMEBUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return (*Framebuffer)(nil), ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffertarget); ϟerr != nil {
return (*Framebuffer)(nil), ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return (*Framebuffer)(nil), ϟerr
}
framebufferId := func() (result FramebufferId) {
switch framebuffertarget {
case GLenum_GL_FRAMEBUFFER:
return ctx.BoundFramebuffers.Get(GLenum_GL_DRAW_FRAMEBUFFER)
case GLenum_GL_DRAW_FRAMEBUFFER:
return ctx.BoundFramebuffers.Get(GLenum_GL_DRAW_FRAMEBUFFER)
case GLenum_GL_READ_FRAMEBUFFER:
return ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", framebuffertarget, ϟa))
return result
}
}()
return ctx.Instances.Framebuffers.Get(framebufferId), nil
}
func subIsDefaultFramebuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, framebuffer *Framebuffer) (bool, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return false, ϟerr
}
return (framebuffer) == (ctx.Instances.Framebuffers.Get(FramebufferId(uint32(0)))), nil
}
func subSetFramebufferAttachment(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, framebuffertarget GLenum, framebufferattachment GLenum, attachment FramebufferAttachment) error {
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffertarget)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsDefaultFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffer)
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (framebufferattachment) == (GLenum_GL_DEPTH_STENCIL_ATTACHMENT) {
framebuffer.Attachments[GLenum_GL_DEPTH_ATTACHMENT] = attachment
framebuffer.Attachments[GLenum_GL_STENCIL_ATTACHMENT] = attachment
} else {
framebuffer.Attachments[framebufferattachment] = attachment
}
return nil
}
func subBlitFramebuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, srcX0 GLint, srcY0 GLint, srcX1 GLint, srcY1 GLint, dstX0 GLint, dstY0 GLint, dstX1 GLint, dstY1 GLint, mask GLbitfield, filter GLenum) error {
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, mask, (GLbitfield_GL_COLOR_BUFFER_BIT)|((GLbitfield_GL_DEPTH_BUFFER_BIT)|(GLbitfield_GL_STENCIL_BUFFER_BIT))); ϟerr != nil {
return ϟerr
}
if (GLbitfield_GL_COLOR_BUFFER_BIT)&(mask) != 0 {
}
if (GLbitfield_GL_DEPTH_BUFFER_BIT)&(mask) != 0 {
}
if (GLbitfield_GL_STENCIL_BUFFER_BIT)&(mask) != 0 {
}
switch filter {
case GLenum_GL_LINEAR, GLenum_GL_NEAREST:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, filter); ϟerr != nil {
return ϟerr
}
}
_ = srcX0
_ = srcY0
_ = srcX1
_ = srcY1
_ = dstX0
_ = dstY0
_ = dstX1
_ = dstY1
return nil
}
func subColorMaski(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, index DrawBufferIndex, r GLboolean, g GLboolean, b GLboolean, a GLboolean) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.ColorWritemask[index] = Vec4b{Elements: [4]GLboolean{r, g, b, a}}
return nil
}
func subDrawBuffers(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, n GLsizei, buffers GLenumᶜᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
b := buffers.Slice(uint64(GLsizei(int32(0))), uint64(n), ϟs)
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_DRAW_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
for i := GLint(int32(0)); i < GLint(n); i++ {
framebuffer.DrawBuffer[i] = b.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
for i := GLint(n); i < ctx.Constants.MaxDrawBuffers; i++ {
framebuffer.DrawBuffer[i] = GLenum_GL_NONE
}
return nil
}
func subFramebufferTexture(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, attachment GLenum, texture TextureId, level GLint) error {
switch attachment {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_DEPTH_STENCIL_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, attachment); ϟerr != nil {
return ϟerr
}
}
attachment_info := FramebufferAttachment{ObjectType: GLenum_GL_NONE, ObjectName: GLuint(uint32(0)), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
if (texture) != (TextureId(uint32(0))) {
attachment_info.ObjectType = GLenum_GL_TEXTURE
attachment_info.ObjectName = GLuint(texture)
attachment_info.TextureLevel = level
attachment_info.Layered = GLboolean(uint8(0))
}
if ϟerr := subSetFramebufferAttachment(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, attachment, attachment_info); ϟerr != nil {
return ϟerr
}
return nil
}
func subFramebufferTexture2D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, framebuffertarget GLenum, framebufferattachment GLenum, texturetarget GLenum, texture TextureId, level GLint) error {
switch framebufferattachment {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
case GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH_STENCIL_ATTACHMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebufferattachment); ϟerr != nil {
return ϟerr
}
}
switch texturetarget {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, texturetarget); ϟerr != nil {
return ϟerr
}
}
if (level) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
attachment := FramebufferAttachment{ObjectType: GLenum_GL_NONE, ObjectName: GLuint(uint32(0)), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
if (texture) != (TextureId(uint32(0))) {
if !(ctx.Instances.Textures.Contains(texture)) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
kind := func() (result GLenum) {
switch texturetarget {
case GLenum_GL_TEXTURE_2D:
return GLenum_GL_TEXTURE_2D
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
return GLenum_GL_TEXTURE_2D_MULTISAMPLE
case GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
return GLenum_GL_TEXTURE_CUBE_MAP
default:
return GLenum(int32(0))
}
}()
if (ctx.Instances.Textures.Get(texture).OnAccess(ϟs).Kind) != (kind) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
attachment.ObjectType = GLenum_GL_TEXTURE
attachment.ObjectName = GLuint(texture)
attachment.TextureLevel = level
attachment.TextureCubeMapFace = func() (result GLenum) {
switch texturetarget {
case GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
return texturetarget
default:
return GLenum_GL_NONE
}
}()
}
if ϟerr := subSetFramebufferAttachment(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffertarget, framebufferattachment, attachment); ϟerr != nil {
return ϟerr
}
return nil
}
func subInvalidateFramebuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, count GLsizei, attachments GLenumᶜᵖ) error {
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
a := attachments.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
_res_0, ϟerr := subIsDefaultFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffer)
if ϟerr != nil {
return ϟerr
}
if _res_0 {
for i := GLsizei(int32(0)); i < count; i++ {
switch a.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb) {
case GLenum_GL_COLOR, GLenum_GL_DEPTH, GLenum_GL_STENCIL:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, a.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)); ϟerr != nil {
return ϟerr
}
}
}
} else {
for i := GLsizei(int32(0)); i < count; i++ {
switch a.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb) {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_DEPTH_STENCIL_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, a.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)); ϟerr != nil {
return ϟerr
}
}
}
}
return nil
}
func subCheckReadPixels(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, width GLsizei, height GLsizei, format GLenum, ty GLenum) error {
switch format {
case GLenum_GL_ALPHA, GLenum_GL_RGB, GLenum_GL_RGBA:
case GLenum_GL_RED, GLenum_GL_RED_INTEGER, GLenum_GL_RG, GLenum_GL_RG_INTEGER, GLenum_GL_RGB_INTEGER, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_LUMINANCE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format); ϟerr != nil {
return ϟerr
}
}
switch ty {
case GLenum_GL_UNSIGNED_SHORT_5_6_5:
if (format) != (GLenum_GL_RGB) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNSIGNED_SHORT_4_4_4_4, GLenum_GL_UNSIGNED_SHORT_5_5_5_1:
if (format) != (GLenum_GL_RGBA) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNSIGNED_BYTE:
case GLenum_GL_FLOAT, GLenum_GL_INT, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV, GLenum_GL_UNSIGNED_INT_5_9_9_9_REV:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
if ((width) < (GLsizei(int32(0)))) || ((height) < (GLsizei(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subReadnPixels(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, x GLint, y GLint, width GLsizei, height GLsizei, format GLenum, ty GLenum, bufSize GLsizei, data Voidᵖ) error {
if ϟerr := subCheckReadPixels(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, width, height, format, ty); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((ctx.BoundBuffers.PixelPackBuffer) == (BufferId(uint32(0)))) && ((data) != (Voidᵖ{})) {
requiredSize, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(width), uint32(height), format, ty)
if ϟerr != nil {
return ϟerr
}
if (GLsizei(requiredSize)) > (bufSize) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
data.Slice(uint64(uint32(0)), uint64(requiredSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
_ = x
_ = y
_ = width
_ = height
return nil
}
func subRenderbufferStorageMultisample(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, samples GLsizei, internalformat GLenum, width GLsizei, height GLsizei) error {
switch target {
case GLenum_GL_RENDERBUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGBA4, GLenum_GL_STENCIL_INDEX8:
case GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB8, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_SRGB8_ALPHA8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_R16, GLenum_GL_RG16, GLenum_GL_RGBA16:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_norm16); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
if ((width) < (GLsizei(int32(0)))) || ((height) < (GLsizei(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((width) > (GLsizei(ctx.Constants.MaxRenderbufferSize))) || ((height) > (GLsizei(ctx.Constants.MaxRenderbufferSize))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
id := ctx.BoundRenderbuffers.Get(target)
if (id) == (RenderbufferId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
rb := ctx.Instances.Renderbuffers.Get(id)
rb.InternalFormat = internalformat
rb.Width = width
rb.Height = height
_ = samples
return nil
}
func subImageSize(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, width uint32, height uint32, format GLenum, ty GLenum) (uint32, error) {
ups, ϟerr := subUncompressedPixelSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format, ty)
if ϟerr != nil {
return uint32(0), ϟerr
}
return func() (result uint32) {
switch ty {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
return (((width) + (uint32(3))) / (uint32(4))) * ((((height) + (uint32(3))) / (uint32(4))) * (uint32(8)))
case GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4:
return (((width) + (uint32(3))) / (uint32(4))) * ((((height) + (uint32(3))) / (uint32(4))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4:
return (((width) + (uint32(4))) / (uint32(5))) * ((((height) + (uint32(3))) / (uint32(4))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5:
return (((width) + (uint32(4))) / (uint32(5))) * ((((height) + (uint32(4))) / (uint32(5))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5:
return (((width) + (uint32(5))) / (uint32(6))) * ((((height) + (uint32(4))) / (uint32(5))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6:
return (((width) + (uint32(5))) / (uint32(6))) * ((((height) + (uint32(5))) / (uint32(6))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5:
return (((width) + (uint32(7))) / (uint32(8))) * ((((height) + (uint32(4))) / (uint32(5))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6:
return (((width) + (uint32(7))) / (uint32(8))) * ((((height) + (uint32(5))) / (uint32(6))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
return (((width) + (uint32(7))) / (uint32(8))) * ((((height) + (uint32(7))) / (uint32(8))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5:
return (((width) + (uint32(9))) / (uint32(10))) * ((((height) + (uint32(4))) / (uint32(5))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6:
return (((width) + (uint32(9))) / (uint32(10))) * ((((height) + (uint32(5))) / (uint32(6))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8:
return (((width) + (uint32(9))) / (uint32(10))) * ((((height) + (uint32(7))) / (uint32(8))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10:
return (((width) + (uint32(9))) / (uint32(10))) * ((((height) + (uint32(9))) / (uint32(10))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10:
return (((width) + (uint32(11))) / (uint32(12))) * ((((height) + (uint32(9))) / (uint32(10))) * (uint32(16)))
case GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12:
return (((width) + (uint32(11))) / (uint32(12))) * ((((height) + (uint32(11))) / (uint32(12))) * (uint32(16)))
case GLenum_GL_ETC1_RGB8_OES:
return (((width) + (uint32(3))) / (uint32(4))) * ((((height) + (uint32(3))) / (uint32(4))) * (uint32(8)))
default:
return (width) * ((height) * (ups))
}
}(), nil
}
func subUncompressedPixelSize(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, format GLenum, ty GLenum) (uint32, error) {
num_components, ϟerr := subComponentCount(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format)
if ϟerr != nil {
return uint32(0), ϟerr
}
return func() (result uint32) {
switch ty {
case GLenum_GL_UNSIGNED_BYTE:
return (num_components) * (uint32(1))
case GLenum_GL_BYTE:
return (num_components) * (uint32(1))
case GLenum_GL_UNSIGNED_SHORT:
return (num_components) * (uint32(2))
case GLenum_GL_SHORT:
return (num_components) * (uint32(2))
case GLenum_GL_UNSIGNED_INT:
return (num_components) * (uint32(4))
case GLenum_GL_INT:
return (num_components) * (uint32(4))
case GLenum_GL_HALF_FLOAT:
return (num_components) * (uint32(2))
case GLenum_GL_HALF_FLOAT_OES:
return (num_components) * (uint32(2))
case GLenum_GL_FLOAT:
return (num_components) * (uint32(4))
case GLenum_GL_UNSIGNED_SHORT_5_6_5:
return uint32(2)
case GLenum_GL_UNSIGNED_SHORT_4_4_4_4:
return uint32(2)
case GLenum_GL_UNSIGNED_SHORT_5_5_5_1:
return uint32(2)
case GLenum_GL_UNSIGNED_INT_2_10_10_10_REV:
return uint32(4)
case GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV:
return uint32(4)
case GLenum_GL_UNSIGNED_INT_5_9_9_9_REV:
return uint32(4)
case GLenum_GL_UNSIGNED_INT_24_8:
return uint32(4)
case GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
return uint32(8)
default:
return uint32(0)
}
}(), nil
}
func subComponentCount(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, format GLenum) (uint32, error) {
return func() (result uint32) {
switch format {
case GLenum_GL_ALPHA:
return uint32(1)
case GLenum_GL_LUMINANCE:
return uint32(1)
case GLenum_GL_LUMINANCE_ALPHA:
return uint32(2)
case GLenum_GL_RED:
return uint32(1)
case GLenum_GL_RED_INTEGER:
return uint32(1)
case GLenum_GL_RG:
return uint32(2)
case GLenum_GL_RG_INTEGER:
return uint32(2)
case GLenum_GL_RGB:
return uint32(3)
case GLenum_GL_RGB_INTEGER:
return uint32(3)
case GLenum_GL_RGBA:
return uint32(4)
case GLenum_GL_RGBA_INTEGER:
return uint32(4)
case GLenum_GL_DEPTH_COMPONENT:
return uint32(1)
case GLenum_GL_DEPTH_STENCIL:
return uint32(2)
case GLenum_GL_STENCIL_INDEX:
return uint32(1)
case GLenum_GL_BGRA_EXT:
return uint32(4)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", format, ϟa))
return result
}
}(), nil
}
func subImageFormat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, internalFormat GLenum) (GLenum, error) {
return func() (result GLenum) {
switch internalFormat {
case GLenum_GL_ALPHA8_EXT:
return GLenum_GL_ALPHA
case GLenum_GL_R8, GLenum_GL_R8_SNORM, GLenum_GL_R16, GLenum_GL_R16_SNORM, GLenum_GL_R16F, GLenum_GL_R32F, GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC:
return GLenum_GL_RED
case GLenum_GL_R8UI, GLenum_GL_R8I, GLenum_GL_R16UI, GLenum_GL_R16I, GLenum_GL_R32UI, GLenum_GL_R32I:
return GLenum_GL_RED_INTEGER
case GLenum_GL_RG8, GLenum_GL_RG8_SNORM, GLenum_GL_RG16, GLenum_GL_RG16_SNORM, GLenum_GL_RG16F, GLenum_GL_RG32F, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC:
return GLenum_GL_RG
case GLenum_GL_RG8UI, GLenum_GL_RG8I, GLenum_GL_RG16UI, GLenum_GL_RG16I, GLenum_GL_RG32UI, GLenum_GL_RG32I:
return GLenum_GL_RG_INTEGER
case GLenum_GL_RGB8, GLenum_GL_SRGB8, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB16, GLenum_GL_RGB16_SNORM, GLenum_GL_RGB565, GLenum_GL_R11F_G11F_B10F, GLenum_GL_RGB9_E5, GLenum_GL_RGB16F, GLenum_GL_RGB32F, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_ETC1_RGB8_OES:
return GLenum_GL_RGB
case GLenum_GL_RGB8UI, GLenum_GL_RGB8I, GLenum_GL_RGB16UI, GLenum_GL_RGB16I, GLenum_GL_RGB32UI, GLenum_GL_RGB32I:
return GLenum_GL_RGB_INTEGER
case GLenum_GL_RGBA8, GLenum_GL_SRGB8_ALPHA8, GLenum_GL_RGBA8_SNORM, GLenum_GL_RGBA16, GLenum_GL_RGBA16_SNORM, GLenum_GL_RGB5_A1, GLenum_GL_RGBA4, GLenum_GL_RGB10_A2, GLenum_GL_RGBA16F, GLenum_GL_RGBA32F, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12:
return GLenum_GL_RGBA
case GLenum_GL_RGBA8UI, GLenum_GL_RGBA8I, GLenum_GL_RGB10_A2UI, GLenum_GL_RGBA16UI, GLenum_GL_RGBA16I, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI:
return GLenum_GL_RGBA_INTEGER
case GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F:
return GLenum_GL_DEPTH_COMPONENT
case GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8:
return GLenum_GL_DEPTH_STENCIL
default:
return internalFormat
}
}(), nil
}
func subImageType(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, internalFormat GLenum) (GLenum, error) {
return func() (result GLenum) {
switch internalFormat {
case GLenum_GL_ALPHA8_EXT:
return GLenum_GL_UNSIGNED_BYTE
case GLenum_GL_R8, GLenum_GL_R8UI, GLenum_GL_RG8, GLenum_GL_RG8UI, GLenum_GL_RGB8, GLenum_GL_SRGB8, GLenum_GL_RGB8UI, GLenum_GL_RGBA8, GLenum_GL_SRGB8_ALPHA8, GLenum_GL_RGBA8UI, GLenum_GL_STENCIL_INDEX8, GLenum_GL_BGRA_EXT:
return GLenum_GL_UNSIGNED_BYTE
case GLenum_GL_R8_SNORM, GLenum_GL_R8I, GLenum_GL_RG8_SNORM, GLenum_GL_RG8I, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB8I, GLenum_GL_RGBA8_SNORM, GLenum_GL_RGBA8I:
return GLenum_GL_BYTE
case GLenum_GL_R16, GLenum_GL_R16UI, GLenum_GL_RG16, GLenum_GL_RG16UI, GLenum_GL_RGB16, GLenum_GL_RGB16UI, GLenum_GL_RGBA16, GLenum_GL_RGBA16UI, GLenum_GL_DEPTH_COMPONENT16:
return GLenum_GL_UNSIGNED_SHORT
case GLenum_GL_R16_SNORM, GLenum_GL_R16I, GLenum_GL_RG16_SNORM, GLenum_GL_RG16I, GLenum_GL_RGB16_SNORM, GLenum_GL_RGB16I, GLenum_GL_RGBA16_SNORM, GLenum_GL_RGBA16I:
return GLenum_GL_SHORT
case GLenum_GL_RGB565:
return GLenum_GL_UNSIGNED_SHORT_5_6_5
case GLenum_GL_RGB5_A1:
return GLenum_GL_UNSIGNED_SHORT_5_5_5_1
case GLenum_GL_RGBA4:
return GLenum_GL_UNSIGNED_SHORT_4_4_4_4
case GLenum_GL_R32UI, GLenum_GL_RG32UI, GLenum_GL_RGB32UI, GLenum_GL_RGBA32UI, GLenum_GL_DEPTH_COMPONENT24:
return GLenum_GL_UNSIGNED_INT
case GLenum_GL_R32I, GLenum_GL_RG32I, GLenum_GL_RGB32I, GLenum_GL_RGBA32I:
return GLenum_GL_INT
case GLenum_GL_R11F_G11F_B10F:
return GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV
case GLenum_GL_RGB9_E5:
return GLenum_GL_UNSIGNED_INT_5_9_9_9_REV
case GLenum_GL_RGB10_A2:
return GLenum_GL_UNSIGNED_INT_2_10_10_10_REV
case GLenum_GL_RGB10_A2UI:
return GLenum_GL_UNSIGNED_INT_2_10_10_10_REV
case GLenum_GL_DEPTH24_STENCIL8:
return GLenum_GL_UNSIGNED_INT_24_8
case GLenum_GL_R16F, GLenum_GL_RG16F, GLenum_GL_RGB16F, GLenum_GL_RGBA16F:
return GLenum_GL_HALF_FLOAT
case GLenum_GL_R32F, GLenum_GL_RG32F, GLenum_GL_RGB32F, GLenum_GL_RGBA32F, GLenum_GL_DEPTH_COMPONENT32F:
return GLenum_GL_FLOAT
case GLenum_GL_DEPTH32F_STENCIL8:
return GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV
default:
return internalFormat
}
}(), nil
}
func subSetCapability(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, capability GLenum, isIndexed bool, index GLuint, enabled GLboolean) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch capability {
case GLenum_GL_BLEND:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
blend := ctx.FragmentOperations.Blend.Get(DrawBufferIndex(index))
blend.Enabled = enabled
ctx.FragmentOperations.Blend[DrawBufferIndex(index)] = blend
} else {
for i := DrawBufferIndex(uint32(0)); i < DrawBufferIndex(uint32(len(ctx.FragmentOperations.Blend))); i++ {
blend := ctx.FragmentOperations.Blend.Get(i)
blend.Enabled = enabled
ctx.FragmentOperations.Blend[i] = blend
}
}
case GLenum_GL_CULL_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.CullFace = enabled
case GLenum_GL_DEPTH_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Depth.Test = enabled
case GLenum_GL_DITHER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Dither = enabled
case GLenum_GL_POLYGON_OFFSET_FILL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.PolygonOffsetFill = enabled
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.SampleAlphaToCoverage = enabled
case GLenum_GL_SAMPLE_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.SampleCoverage = enabled
case GLenum_GL_SCISSOR_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Scissor.Test = enabled
case GLenum_GL_STENCIL_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Stencil.Test = enabled
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Miscellaneous.PrimitiveRestartFixedIndex = enabled
case GLenum_GL_RASTERIZER_DISCARD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.RasterizerDiscard = enabled
case GLenum_GL_SAMPLE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.Rasterization.SampleMask = enabled
case GLenum_GL_DEBUG_OUTPUT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
ctx.Debug.Output = enabled
case GLenum_GL_DEBUG_OUTPUT_SYNCHRONOUS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
ctx.Debug.OutputSynchronous = enabled
case GLenum_GL_ALPHA_TEST_QCOM:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_alpha_test); ϟerr != nil {
return ϟerr
}
case GLenum_GL_FRAMEBUFFER_SRGB_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_sRGB_write_control); ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.FramebufferSrgb = enabled
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, capability); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetCapability(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, capability GLenum, index GLuint) (GLboolean, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
switch capability {
case GLenum_GL_BLEND:
case GLenum_GL_CULL_FACE, GLenum_GL_DEPTH_TEST, GLenum_GL_DITHER, GLenum_GL_POLYGON_OFFSET_FILL, GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE, GLenum_GL_SAMPLE_COVERAGE, GLenum_GL_SCISSOR_TEST, GLenum_GL_STENCIL_TEST:
if (index) > (GLuint(uint32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
}
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX, GLenum_GL_RASTERIZER_DISCARD:
if (index) > (GLuint(uint32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
}
case GLenum_GL_SAMPLE_MASK:
if (index) > (GLuint(uint32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
}
case GLenum_GL_DEBUG_OUTPUT, GLenum_GL_DEBUG_OUTPUT_SYNCHRONOUS:
if (index) > (GLuint(uint32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
}
default:
}
return func() (result GLboolean) {
switch capability {
case GLenum_GL_BLEND:
return ctx.FragmentOperations.Blend.Get(DrawBufferIndex(index)).Enabled
case GLenum_GL_CULL_FACE:
return ctx.Rasterization.CullFace
case GLenum_GL_DEPTH_TEST:
return ctx.FragmentOperations.Depth.Test
case GLenum_GL_DITHER:
return ctx.FragmentOperations.Dither
case GLenum_GL_POLYGON_OFFSET_FILL:
return ctx.Rasterization.PolygonOffsetFill
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
return ctx.Rasterization.SampleAlphaToCoverage
case GLenum_GL_SAMPLE_COVERAGE:
return ctx.Rasterization.SampleCoverage
case GLenum_GL_SCISSOR_TEST:
return ctx.FragmentOperations.Scissor.Test
case GLenum_GL_STENCIL_TEST:
return ctx.FragmentOperations.Stencil.Test
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
return ctx.Miscellaneous.PrimitiveRestartFixedIndex
case GLenum_GL_RASTERIZER_DISCARD:
return ctx.Rasterization.RasterizerDiscard
case GLenum_GL_SAMPLE_MASK:
return ctx.Rasterization.SampleMask
case GLenum_GL_DEBUG_OUTPUT:
return ctx.Debug.Output
case GLenum_GL_DEBUG_OUTPUT_SYNCHRONOUS:
return ctx.Debug.OutputSynchronous
case GLenum_GL_ALPHA_TEST_QCOM:
return GLboolean_GL_FALSE
case GLenum_GL_FRAMEBUFFER_SRGB_EXT:
return ctx.FragmentOperations.FramebufferSrgb
default:
return GLboolean_GL_FALSE
}
}(), nil
}
func subDisablei(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, capability GLenum, index GLuint) error {
if ϟerr := subSetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, capability, true, index, GLboolean_GL_FALSE); ϟerr != nil {
return ϟerr
}
return nil
}
func subEnablei(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, capability GLenum, index GLuint) error {
if ϟerr := subSetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, capability, true, index, GLboolean_GL_TRUE); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetGraphicsResetStatus(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
return nil
}
func subReadString(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, length GLsizei, buffer GLcharᶜᵖ) error {
if (buffer) != (GLcharᶜᵖ{}) {
if (length) < (GLsizei(int32(0))) {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(buffer).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
} else {
buffer.Slice(uint64(GLsizei(int32(0))), uint64(length), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
}
return nil
}
func subWriteString(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, buffersize GLsizei, bufferbyteswritten GLsizeiᵖ, buffer GLcharᵖ) error {
if ((buffer) != (GLcharᵖ{})) && ((buffersize) > (GLsizei(int32(0)))) {
if (bufferbyteswritten) != (GLsizeiᵖ{}) {
length := GLsizei(bufferbyteswritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
bufferbyteswritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, length, ϟa, ϟs, ϟd, ϟb)
buffer.Slice(uint64(GLsizei(int32(0))), uint64((length)+(GLsizei(int32(1)))), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
buffer.Slice(uint64(GLsizei(int32(0))), uint64(buffersize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
}
return nil
}
func subCheckShader(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, shader ShaderId) error {
if !(ctx.Instances.Shaders.Contains(shader)) {
if !(ctx.Instances.Programs.Contains(ProgramId(shader))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
} else {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
}
return nil
}
func subCheckProgram(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, program ProgramId) error {
if !(ctx.Instances.Programs.Contains(program)) {
if !(ctx.Instances.Shaders.Contains(ShaderId(program))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
} else {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
}
return nil
}
func subReapShader(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, shaderId ShaderId, shader *Shader) error {
if (shader.OnAccess(ϟs).DeleteStatus) && ((shader.OnAccess(ϟs).RefCount) == (GLuint(uint32(0)))) {
delete(ctx.Instances.Shaders, shaderId)
}
return nil
}
func subReapProgram(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, program ProgramId) error {
if (program) != (ProgramId(uint32(0))) {
p := ctx.Instances.Programs.Get(program)
if p.OnAccess(ϟs).DeleteStatus {
{
for _, v := range p.OnAccess(ϟs).Shaders {
s := ctx.Instances.Shaders.Get(v)
s.OnAccess(ϟs).RefCount -= GLuint(uint32(1))
if ϟerr := subReapShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, v, s); ϟerr != nil {
return ϟerr
}
}
}
delete(ctx.Instances.Programs, program)
}
}
return nil
}
func subSetProgramUniform(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value U8ˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, program); ϟerr != nil {
return ϟerr
}
p := ctx.Instances.Programs.Get(program)
if (location) != (UniformLocation(int32(-1))) {
if !(p.OnAccess(ϟs).Uniforms.Contains(location)) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
u := p.OnAccess(ϟs).Uniforms.Get(location)
if (int32(u.Value.Count)) == (int32(value.Count)) {
u.Value.Copy(ϟctx, value, ϟa, ϟs, ϟd, ϟb)
} else {
u.Value = value.Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
u.Type = ty
p.OnAccess(ϟs).Uniforms[location] = u
}
return nil
}
func subGetProgramBinary(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, bufSize GLsizei, length GLsizeiᵖ, binaryFormat GLenumᵖ, binary Voidᵖ) error {
_ = program
if (length) != (GLsizeiᵖ{}) {
l := GLsizei(length.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
length.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, l, ϟa, ϟs, ϟd, ϟb)
binary.Slice(uint64(GLsizei(int32(0))), uint64(l), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
binary.Slice(uint64(GLsizei(int32(0))), uint64(bufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
binaryFormat.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, binaryFormat.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
func subGetnUniformiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, bufSize GLsizei, values GLintᵖ) error {
if ϟerr := subGetnUniformfv_GLint__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, bufSize, values); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetnUniformuiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, bufSize GLsizei, values GLuintᵖ) error {
if ϟerr := subGetnUniformfv_GLuint__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, bufSize, values); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramBinary(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, binaryFormat GLenum, binary Voidᶜᵖ, length GLsizei) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, program); ϟerr != nil {
return ϟerr
}
p := ctx.Instances.Programs.Get(program)
switch binaryFormat {
case GLenum_GL_Z400_BINARY_AMD:
p.OnAccess(ϟs).Binary = AsU8ˢ(binary.Slice(uint64(GLsizei(int32(0))), uint64(length), ϟs), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
p.OnAccess(ϟs).Precompiled = true
if ϟerr := subApplyProgramInfoExtra(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetProgramInfoExtra(program))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, binaryFormat); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subProgramParameteri(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, pname GLenum, value GLint) error {
switch pname {
case GLenum_GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
case GLenum_GL_PROGRAM_SEPARABLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
_ = program
_ = value
return nil
}
func subProgramUniform1f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLfloat) error {
v := MakeGLfloatˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, value0, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_GLfloat__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform1fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLfloatᶜᵖ) error {
v := values.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_GLfloat__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform1i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLint) error {
v := MakeGLintˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, value0, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_GLint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform1iv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLintᶜᵖ) error {
v := values.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_GLint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform1ui(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLuint) error {
v := MakeGLuintˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, value0, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_GLuint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform1uiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLuintᶜᵖ) error {
v := values.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_GLuint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLfloat, value1 GLfloat) error {
v := MakeVec2fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2f{Elements: [2]GLfloat{value0, value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLfloatᶜᵖ) error {
v := Vec2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLint, value1 GLint) error {
v := MakeVec2iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2i{Elements: [2]GLint{value0, value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec2i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2iv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLintᶜᵖ) error {
v := Vec2iᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec2i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2ui(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLuint, value1 GLuint) error {
v := MakeVec2uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2u{Elements: [2]GLuint{value0, value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec2u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform2uiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLuintᶜᵖ) error {
v := Vec2uᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec2u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLfloat, value1 GLfloat, value2 GLfloat) error {
v := MakeVec3fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3f{Elements: [3]GLfloat{value0, value1, value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLfloatᶜᵖ) error {
v := Vec3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLint, value1 GLint, value2 GLint) error {
v := MakeVec3iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3i{Elements: [3]GLint{value0, value1, value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec3i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3iv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLintᶜᵖ) error {
v := Vec3iᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec3i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3ui(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLuint, value1 GLuint, value2 GLuint) error {
v := MakeVec3uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3u{Elements: [3]GLuint{value0, value1, value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec3u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform3uiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLuintᶜᵖ) error {
v := Vec3uᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec3u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLfloat, value1 GLfloat, value2 GLfloat, value3 GLfloat) error {
v := MakeVec4fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4f{Elements: [4]GLfloat{value0, value1, value2, value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLfloatᶜᵖ) error {
v := Vec4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_FLOAT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLint, value1 GLint, value2 GLint, value3 GLint) error {
v := MakeVec4iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4i{Elements: [4]GLint{value0, value1, value2, value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec4i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4iv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLintᶜᵖ) error {
v := Vec4iᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec4i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_INT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4ui(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, value0 GLuint, value1 GLuint, value2 GLuint, value3 GLuint) error {
v := MakeVec4uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4u{Elements: [4]GLuint{value0, value1, value2, value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subProgramUniformv_Vec4u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniform4uiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, values GLuintᶜᵖ) error {
v := Vec4uᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformv_Vec4u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, v, GLenum_GL_UNSIGNED_INT_VEC4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix2x3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat2x3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat2x3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT2x3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix2x4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat2x4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat2x4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT2x4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT3); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix3x2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat3x2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat3x2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT3x2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix3x4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat3x4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat3x4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT3x4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT4); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix4x2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat4x2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat4x2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT4x2); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrix4x3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat4x3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subProgramUniformMatrixv_Mat4x3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, transpose, v, GLenum_GL_FLOAT_MAT4x3); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix2x3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat2x3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat2x3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT2x3); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix2x4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat2x4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat2x4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT2x4); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix3x2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat3x2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat3x2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT3x2); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix3x4fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat3x4fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat3x4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT3x4); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix4x2fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat4x2fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat4x2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT4x2); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrix4x3fv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, count GLsizei, transpose GLboolean, values GLfloatᶜᵖ) error {
v := Mat4x3fᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
if ϟerr := subUniformMatrixv_Mat4x3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, location, transpose, v, GLenum_GL_FLOAT_MAT4x3); ϟerr != nil {
return ϟerr
}
return nil
}
func subMinSampleShading(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, value GLfloat) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.MinSampleShadingValue = value
return nil
}
func subVersionGreaterOrEqual(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, major GLint, minor GLint) (bool, error) {
return ((ctx.Constants.MajorVersion) > (major)) || (((ctx.Constants.MajorVersion) == (major)) && ((ctx.Constants.MinorVersion) >= (minor))), nil
}
func subGetInteger64v(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, param GLenum, values GLint64ᵖ) error {
if ϟerr := subGetStateVariable_GLint64(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, param, false, GLuint(uint32(0)), values); ϟerr != nil {
return ϟerr
}
return nil
}
func subIsEnabledi(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, capability GLenum, index GLuint) (GLboolean, error) {
_res_0, ϟerr := subGetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, capability, index)
if ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
return _res_0, nil
}
func subClientWaitSync(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sync GLsync, syncFlags GLbitfield, timeout GLuint64) error {
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, syncFlags, GLbitfield_GL_SYNC_FLUSH_COMMANDS_BIT); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.SyncObjects.Contains(sync)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (GLbitfield_GL_SYNC_FLUSH_COMMANDS_BIT)&(syncFlags) != 0 {
}
_ = timeout
return nil
}
func subDeleteSync(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sync GLsync) error {
if (sync) != (GLsync(Voidᵖ{})) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.SyncObjects.Contains(sync)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
delete(ctx.Instances.SyncObjects, sync)
}
return nil
}
func subFenceSync(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, condition GLenum, syncFlags GLbitfield, sync GLsync) error {
if (condition) != (GLenum_GL_SYNC_GPU_COMMANDS_COMPLETE) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, condition); ϟerr != nil {
return ϟerr
}
}
if (syncFlags) != (GLbitfield(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (sync) != (GLsync(Voidᵖ{})) {
ctx.Instances.SyncObjects[sync] = &SyncObject{}
}
return nil
}
func subGetSynciv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sync GLsync, pname GLenum, bufSize GLsizei, length GLsizeiᵖ, values GLintᵖ) error {
_ = sync
switch pname {
case GLenum_GL_OBJECT_TYPE, GLenum_GL_SYNC_CONDITION, GLenum_GL_SYNC_FLAGS, GLenum_GL_SYNC_STATUS:
if ((values) != (GLintᵖ{})) && ((bufSize) > (GLsizei(int32(0)))) {
values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
if (length) != (GLsizeiᵖ{}) {
length.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLsizei(int32(1)), ϟa, ϟs, ϟd, ϟb)
}
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subIsSync(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sync GLsync) (GLboolean, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
return func() GLboolean {
if ctx.Instances.SyncObjects.Contains(sync) {
return 1
} else {
return 0
}
}(), nil
}
func subWaitSync(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sync GLsync, syncFlags GLbitfield, timeout GLuint64) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.SyncObjects.Contains(sync)) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (timeout) != (GLuint64(uint64(18446744073709551615))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (syncFlags) != (GLbitfield(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetBoundTextureOrErrorInvalidEnum(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum) (*Texture, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return (*Texture)(nil), ϟerr
}
tu := ctx.TextureUnits.Get(ctx.ActiveTextureUnit)
return func() (result *Texture) {
switch target {
case GLenum_GL_TEXTURE_2D:
return func() (result *Texture) {
switch (tu.Binding2d) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.Binding2d)
case false:
return ctx.Instances.DefaultTextures.Texture2d
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.Binding2d) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_EXTERNAL_OES:
return func() (result *Texture) {
switch (tu.BindingExternalOes) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.BindingExternalOes)
case false:
return ctx.Instances.DefaultTextures.TextureExternalOes
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.BindingExternalOes) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_2D_ARRAY:
return func() (result *Texture) {
switch (tu.Binding2dArray) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.Binding2dArray)
case false:
return ctx.Instances.DefaultTextures.Texture2dArray
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.Binding2dArray) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
return func() (result *Texture) {
switch (tu.Binding2dMultisample) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.Binding2dMultisample)
case false:
return ctx.Instances.DefaultTextures.Texture2dMultisample
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.Binding2dMultisample) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
return func() (result *Texture) {
switch (tu.Binding2dMultisampleArray) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.Binding2dMultisampleArray)
case false:
return ctx.Instances.DefaultTextures.Texture2dMultisampleArray
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.Binding2dMultisampleArray) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_3D:
return func() (result *Texture) {
switch (tu.Binding3d) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.Binding3d)
case false:
return ctx.Instances.DefaultTextures.Texture3d
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.Binding3d) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_BUFFER:
return func() (result *Texture) {
switch (tu.BindingBuffer) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.BindingBuffer)
case false:
return ctx.Instances.DefaultTextures.TextureBuffer
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.BindingBuffer) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_CUBE_MAP:
return func() (result *Texture) {
switch (tu.BindingCubeMap) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.BindingCubeMap)
case false:
return ctx.Instances.DefaultTextures.TextureCubeMap
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.BindingCubeMap) != (TextureId(uint32(0))), ϟa))
return result
}
}()
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
return func() (result *Texture) {
switch (tu.BindingCubeMapArray) != (TextureId(uint32(0))) {
case true:
return ctx.Instances.Textures.Get(tu.BindingCubeMapArray)
case false:
return ctx.Instances.DefaultTextures.TextureCubeMapArray
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (tu.BindingCubeMapArray) != (TextureId(uint32(0))), ϟa))
return result
}
}()
default:
return ctx.Instances.DefaultTextures.Texture2d
}
}(), nil
}
func subCheckInternalFormat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, internalformat GLenum) error {
switch internalformat {
case GLenum_GL_RGB, GLenum_GL_RGBA, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_LUMINANCE, GLenum_GL_ALPHA, GLenum_GL_R8, GLenum_GL_R8_SNORM, GLenum_GL_R16F, GLenum_GL_R32F, GLenum_GL_R8UI, GLenum_GL_R8I, GLenum_GL_R16UI, GLenum_GL_R16I, GLenum_GL_R32UI, GLenum_GL_R32I, GLenum_GL_RG8, GLenum_GL_RG8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG32F, GLenum_GL_RG8UI, GLenum_GL_RG8I, GLenum_GL_RG16UI, GLenum_GL_RG16I, GLenum_GL_RG32UI, GLenum_GL_RG32I, GLenum_GL_RGB8, GLenum_GL_SRGB8, GLenum_GL_RGB565, GLenum_GL_RGB8_SNORM, GLenum_GL_R11F_G11F_B10F, GLenum_GL_RGB9_E5, GLenum_GL_RGB16F, GLenum_GL_RGB32F, GLenum_GL_RGB8UI, GLenum_GL_RGB8I, GLenum_GL_RGB16UI, GLenum_GL_RGB16I, GLenum_GL_RGB32UI, GLenum_GL_RGB32I, GLenum_GL_RGBA8, GLenum_GL_SRGB8_ALPHA8, GLenum_GL_RGBA8_SNORM, GLenum_GL_RGB5_A1, GLenum_GL_RGBA4, GLenum_GL_RGB10_A2, GLenum_GL_RGBA16F, GLenum_GL_RGBA32F, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8I, GLenum_GL_RGB10_A2UI, GLenum_GL_RGBA16UI, GLenum_GL_RGBA16I, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_STENCIL_INDEX8:
case GLenum_GL_DEPTH_COMPONENT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_depth_texture); ϟerr != nil {
return ϟerr
}
case GLenum_GL_DEPTH_STENCIL:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_packed_depth_stencil); ϟerr != nil {
return ϟerr
}
case GLenum_GL_RED_EXT, GLenum_GL_RG_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_rg); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BGRA_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_format_BGRA8888); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subCheckMaxTextureSize(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, target GLenum, level GLint, width GLsizei, height GLsizei) error {
maxSize := func() (result GLint) {
switch target {
case GLenum_GL_TEXTURE_2D:
return ctx.Constants.MaxTextureSize
case GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
return ctx.Constants.MaxCubeMapTextureSize
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", target, ϟa))
return result
}
}()
if ((level) < (GLint(int32(0)))) || (((width) < (GLsizei(int32(0)))) || (((height) < (GLsizei(int32(0)))) || (((width) > (GLsizei(maxSize))) || (((height) > (GLsizei(maxSize))) || (((uint32(level)) > (uint32(31))) || (((uint32(1)) << (uint32(level))) > (uint32(maxSize)))))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subCompressedTexImage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, level GLint, internalformat GLenum, width GLsizei, height GLsizei, depth GLsizei, border GLint, imagesize GLsizei, data TexturePointer) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_compression_s3tc); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
_ = level
_ = width
_ = height
_ = depth
_ = border
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) && ((data) != (TexturePointer(Voidᶜᵖ{}))) {
U8ᵖ(data).Slice(uint64(GLsizei(int32(0))), uint64(imagesize), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subCompressedTexSubImage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, level GLint, xoffset GLint, yoffset GLint, zoffset GLint, width GLsizei, height GLsizei, depth GLsizei, format GLenum, imagesize GLsizei, data TexturePointer) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch format {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_compression_s3tc); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format); ϟerr != nil {
return ϟerr
}
}
_ = level
_ = xoffset
_ = yoffset
_ = zoffset
_ = width
_ = height
_ = depth
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) && ((data) != (TexturePointer(Voidᶜᵖ{}))) {
U8ᵖ(data).Slice(uint64(GLsizei(int32(0))), uint64(imagesize), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subCopyImageSubData(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, srcName GLuint, srcTarget GLenum, srcLevel GLint, srcX GLint, srcY GLint, srcZ GLint, dstName GLuint, dstTarget GLenum, dstLevel GLint, dstX GLint, dstY GLint, dstZ GLint, srcWidth GLsizei, srcHeight GLsizei, srcDepth GLsizei) error {
switch srcTarget {
case GLenum_GL_RENDERBUFFER, GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_2D_MULTISAMPLE, GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_3D, GLenum_GL_TEXTURE_CUBE_MAP, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, srcTarget); ϟerr != nil {
return ϟerr
}
}
switch dstTarget {
case GLenum_GL_RENDERBUFFER, GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_2D_MULTISAMPLE, GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_3D, GLenum_GL_TEXTURE_CUBE_MAP, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, dstTarget); ϟerr != nil {
return ϟerr
}
}
_ = srcName
_ = srcLevel
_ = srcX
_ = srcY
_ = srcZ
_ = dstName
_ = dstLevel
_ = dstX
_ = dstY
_ = dstZ
_ = srcWidth
_ = srcHeight
_ = srcDepth
return nil
}
func subCopyTexSubImage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, level GLint, xoffset GLint, yoffset GLint, zoffset GLint, x GLint, y GLint, width GLsizei, height GLsizei) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, target, level, width, height); ϟerr != nil {
return ϟerr
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
if !(t.OnAccess(ϟs).Texture2D.Contains(level)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
l := t.OnAccess(ϟs).Texture2D.Get(level)
if ((xoffset) < (GLint(int32(0)))) || (((yoffset) < (GLint(int32(0)))) || ((zoffset) < (GLint(int32(0))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (((GLsizei(xoffset)) + (width)) > (l.Width)) || (((GLsizei(yoffset)) + (height)) > (l.Height)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
_ = level
_ = xoffset
_ = yoffset
_ = zoffset
_ = x
_ = y
_ = width
_ = height
return nil
}
func subGetSamplerParameterIiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLintᵖ) error {
if ϟerr := subGetSamplerParameterv_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, sampler, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetSamplerParameterIuiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLuintᵖ) error {
if ϟerr := subGetSamplerParameterv_GLuint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, sampler, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetTexParameterIiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLintᵖ) error {
if ϟerr := subGetTexParameter_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetTexParameterIuiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLuintᵖ) error {
if ϟerr := subGetTexParameter_GLuint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subSamplerParameterIiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, param GLintᶜᵖ) error {
if ϟerr := subSamplerParameterv_GLint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, sampler, pname, param); ϟerr != nil {
return ϟerr
}
return nil
}
func subSamplerParameterIuiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, param GLuintᶜᵖ) error {
if ϟerr := subSamplerParameterv_GLuint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, sampler, pname, param); ϟerr != nil {
return ϟerr
}
return nil
}
func subTexBuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, internalformat GLenum, buffer BufferId) error {
switch target {
case GLenum_GL_TEXTURE_BUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_R16, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_RG16, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGBA16, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
_ = buffer
return nil
}
func subTexBufferRange(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, internalformat GLenum, buffer BufferId, offset GLintptr, size GLsizeiptr) error {
switch target {
case GLenum_GL_TEXTURE_BUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_R16, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_RG16, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGBA16, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
_ = buffer
_ = offset
_ = size
return nil
}
func subTexImage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, level GLint, internalformat GLint, width GLsizei, height GLsizei, depth GLsizei, border GLint, format GLenum, ty GLenum, data TexturePointer) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subCheckInternalFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(internalformat)); ϟerr != nil {
return ϟerr
}
switch format {
case GLenum_GL_ALPHA, GLenum_GL_DEPTH_COMPONENT, GLenum_GL_DEPTH_STENCIL, GLenum_GL_LUMINANCE, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_RED, GLenum_GL_RED_INTEGER, GLenum_GL_RG, GLenum_GL_RGB, GLenum_GL_RGBA, GLenum_GL_RGBA_INTEGER, GLenum_GL_RGB_INTEGER, GLenum_GL_RG_INTEGER:
case GLenum_GL_STENCIL_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format); ϟerr != nil {
return ϟerr
}
}
switch ty {
case GLenum_GL_HALF_FLOAT_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_half_float); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BYTE, GLenum_GL_FLOAT, GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GLenum_GL_HALF_FLOAT, GLenum_GL_INT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV, GLenum_GL_UNSIGNED_INT_24_8, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_5_9_9_9_REV, GLenum_GL_UNSIGNED_SHORT, GLenum_GL_UNSIGNED_SHORT_4_4_4_4, GLenum_GL_UNSIGNED_SHORT_5_5_5_1, GLenum_GL_UNSIGNED_SHORT_5_6_5:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
_ = level
_ = internalformat
_ = border
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((data) != (TexturePointer(Voidᶜᵖ{}))) && ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) {
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(width), uint32(height), format, ty)
if ϟerr != nil {
return ϟerr
}
size := (_res_0) * (uint32(depth))
U8ᵖ(data).Slice(uint64(uint32(0)), uint64(size), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subCheckWrapParam(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, wrap GLenum) (GLenum, error) {
switch wrap {
case GLenum_GL_CLAMP_TO_EDGE, GLenum_GL_REPEAT, GLenum_GL_MIRRORED_REPEAT, GLenum_GL_CLAMP_TO_BORDER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, wrap); ϟerr != nil {
return GLenum(0), ϟerr
}
}
return wrap, nil
}
func subCheckSwizzleParam(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, swizzle GLenum) (GLenum, error) {
switch swizzle {
case GLenum_GL_RED, GLenum_GL_GREEN, GLenum_GL_BLUE, GLenum_GL_ALPHA, GLenum_GL_ZERO, GLenum_GL_ONE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, swizzle); ϟerr != nil {
return GLenum(0), ϟerr
}
}
return swizzle, nil
}
func subTexParameterIiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLintᶜᵖ) error {
if ϟerr := subTexParameterv_GLint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subTexParameterIuiv(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLuintᶜᵖ) error {
if ϟerr := subTexParameterv_GLuint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target, pname, params); ϟerr != nil {
return ϟerr
}
return nil
}
func subTexStorage2D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, levels GLsizei, internalformat GLenum, width GLsizei, height GLsizei) error {
switch target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
if (levels) < (GLsizei(int32(1))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R11F_G11F_B10F, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_R8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RG8_SNORM, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB16F, GLenum_GL_RGB16I, GLenum_GL_RGB16UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGB8I, GLenum_GL_RGB8UI, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB9_E5, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8:
case GLenum_GL_R16, GLenum_GL_R16_SNORM, GLenum_GL_RG16, GLenum_GL_RG16_SNORM, GLenum_GL_RGB16, GLenum_GL_RGB16_SNORM, GLenum_GL_RGBA16, GLenum_GL_RGBA16_SNORM:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_norm16); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8, GLenum_GL_STENCIL_INDEX8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ALPHA8_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ETC1_RGB8_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_compressed_ETC1_RGB8_texture); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
fm, ϟerr := subImageFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat)
if ϟerr != nil {
return ϟerr
}
ty, ϟerr := subImageType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat)
if ϟerr != nil {
return ϟerr
}
switch target {
case GLenum_GL_TEXTURE_2D:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_2D)
if ϟerr != nil {
return ϟerr
}
for i := GLint(int32(0)); i < GLint(levels); i++ {
w, ϟerr := subMax_GLsizei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, (width)>>(uint32(i)), GLsizei(int32(1)))
if ϟerr != nil {
return ϟerr
}
h, ϟerr := subMax_GLsizei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, (height)>>(uint32(i)), GLsizei(int32(1)))
if ϟerr != nil {
return ϟerr
}
s, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(w), uint32(h), fm, ty)
if ϟerr != nil {
return ϟerr
}
l := Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
t.OnAccess(ϟs).Texture2D[i] = l
}
t.OnAccess(ϟs).TexelFormat = fm
t.OnAccess(ϟs).TexelType = ty
t.OnAccess(ϟs).ImmutableFormat = GLboolean_GL_TRUE
case GLenum_GL_TEXTURE_CUBE_MAP:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_CUBE_MAP)
if ϟerr != nil {
return ϟerr
}
for i := GLint(int32(0)); i < GLint(levels); i++ {
w, ϟerr := subMax_GLsizei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, (width)>>(uint32(i)), GLsizei(int32(1)))
if ϟerr != nil {
return ϟerr
}
h, ϟerr := subMax_GLsizei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, (height)>>(uint32(i)), GLsizei(int32(1)))
if ϟerr != nil {
return ϟerr
}
s, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(w), uint32(h), fm, ty)
if ϟerr != nil {
return ϟerr
}
cube := t.OnAccess(ϟs).Cubemap.Get(i)
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
cube.Faces[GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z] = Image{Width: w, Height: h, Data: MakeU8ˢ(uint64(s), ϟs), Size: s, TexelFormat: fm, TexelType: ty}
t.OnAccess(ϟs).Cubemap[i] = cube
}
t.OnAccess(ϟs).TexelFormat = fm
t.OnAccess(ϟs).TexelType = ty
t.OnAccess(ϟs).ImmutableFormat = GLboolean_GL_TRUE
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexStorage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, levels GLsizei, internalformat GLenum, width GLsizei, height GLsizei, depth GLsizei) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R11F_G11F_B10F, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_R8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RG8_SNORM, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB16F, GLenum_GL_RGB16I, GLenum_GL_RGB16UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGB8I, GLenum_GL_RGB8UI, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB9_E5, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8:
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8, GLenum_GL_STENCIL_INDEX8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
_ = levels
_ = width
_ = height
_ = depth
return nil
}
func subTexStorage3DMultisample(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, samples GLsizei, internalformat GLenum, width GLsizei, height GLsizei, depth GLsizei, fixedsamplelocations GLboolean) error {
switch target {
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch internalformat {
case GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R11F_G11F_B10F, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_R8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RG8_SNORM, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB16F, GLenum_GL_RGB16I, GLenum_GL_RGB16UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGB8I, GLenum_GL_RGB8UI, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB9_E5, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8, GLenum_GL_STENCIL_INDEX8:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, internalformat); ϟerr != nil {
return ϟerr
}
}
_ = samples
_ = width
_ = height
_ = depth
_ = fixedsamplelocations
return nil
}
func subTexSubImage3D(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, level GLint, xoffset GLint, yoffset GLint, zoffset GLint, width GLsizei, height GLsizei, depth GLsizei, format GLenum, ty GLenum, data TexturePointer) error {
switch target {
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
switch format {
case GLenum_GL_ALPHA, GLenum_GL_DEPTH_COMPONENT, GLenum_GL_DEPTH_STENCIL, GLenum_GL_LUMINANCE, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_RED, GLenum_GL_RED_INTEGER, GLenum_GL_RG, GLenum_GL_RGB, GLenum_GL_RGBA, GLenum_GL_RGBA_INTEGER, GLenum_GL_RGB_INTEGER, GLenum_GL_RG_INTEGER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, format); ϟerr != nil {
return ϟerr
}
}
switch ty {
case GLenum_GL_HALF_FLOAT_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_half_float); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BYTE, GLenum_GL_FLOAT, GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GLenum_GL_HALF_FLOAT, GLenum_GL_INT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV, GLenum_GL_UNSIGNED_INT_24_8, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_5_9_9_9_REV, GLenum_GL_UNSIGNED_SHORT, GLenum_GL_UNSIGNED_SHORT_4_4_4_4, GLenum_GL_UNSIGNED_SHORT_5_5_5_1, GLenum_GL_UNSIGNED_SHORT_5_6_5:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
_ = level
_ = xoffset
_ = yoffset
_ = zoffset
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((data) != (TexturePointer(Voidᶜᵖ{}))) && ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) {
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(width), uint32(height), format, ty)
if ϟerr != nil {
return ϟerr
}
size := (_res_0) * (uint32(depth))
U8ᵖ(data).Slice(uint64(uint32(0)), uint64(size), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subGetBoundTransformFeedback(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) (*TransformFeedback, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return (*TransformFeedback)(nil), ϟerr
}
return ctx.Instances.TransformFeedbacks.Get(ctx.BoundTransformFeedback), nil
}
func subNewVertexArray(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context) (*VertexArray, error) {
array := &VertexArray{VertexBufferBindings: VertexBufferBindingIndexːVertexBufferBindingʳᵐ{}, VertexAttributeArrays: AttributeLocationːVertexAttributeArrayʳᵐ{}, ElementArrayBuffer: BufferId(uint32(0))}
_res_0, ϟerr := subVersionGreaterOrEqual(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, GLint(int32(3)), GLint(int32(1)))
if ϟerr != nil {
return (*VertexArray)(nil), ϟerr
}
if _res_0 {
for i := VertexBufferBindingIndex(uint32(0)); i < VertexBufferBindingIndex(ctx.Constants.MaxVertexAttribBindings); i++ {
array.VertexBufferBindings[i] = &VertexBufferBinding{Offset: GLintptr(int32(0)), Stride: GLsizei(int32(16)), Divisor: GLuint(uint32(0)), Buffer: BufferId(uint32(0))}
}
} else {
for i := VertexBufferBindingIndex(uint32(0)); i < VertexBufferBindingIndex(ctx.Constants.MaxVertexAttribs); i++ {
array.VertexBufferBindings[i] = &VertexBufferBinding{Offset: GLintptr(int32(0)), Stride: GLsizei(int32(16)), Divisor: GLuint(uint32(0)), Buffer: BufferId(uint32(0))}
}
}
for i := AttributeLocation(uint32(0)); i < AttributeLocation(ctx.Constants.MaxVertexAttribs); i++ {
array.VertexAttributeArrays[i] = &VertexAttributeArray{Enabled: GLboolean_GL_FALSE, Size: GLint(int32(4)), Stride: GLsizei(int32(0)), Type: GLenum_GL_FLOAT, Normalized: GLboolean_GL_FALSE, Integer: GLboolean_GL_FALSE, Divisor: GLuint(uint32(0)), BufferBinding: GLuint(uint32(0)), Binding: VertexBufferBindingIndex(i), RelativeOffset: GLuint(uint32(0))}
}
return array, nil
}
func subGetVertexAttrib(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, index AttributeLocation, pname GLenum) (uint64, error) {
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
array := vao.VertexAttributeArrays.Get(index)
return func() (result uint64) {
switch pname {
case GLenum_GL_VERTEX_ATTRIB_ARRAY_ENABLED:
return uint64(array.Enabled)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_SIZE:
return uint64(array.Size)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_TYPE:
return uint64(array.Type)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
return uint64(array.Normalized)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_STRIDE:
return uint64(array.Stride)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
return uint64(vao.VertexBufferBindings.Get(array.Binding).Buffer)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
return uint64(vao.VertexBufferBindings.Get(array.Binding).Divisor)
case GLenum_GL_VERTEX_ATTRIB_ARRAY_INTEGER:
return uint64(array.Integer)
case GLenum_GL_VERTEX_ATTRIB_BINDING:
return uint64(array.Binding)
case GLenum_GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
return uint64(array.RelativeOffset)
default:
return uint64(0)
}
}(), nil
}
func subVertexAttribTypeSize(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ty GLenum) (GLint, error) {
return func() (result GLint) {
switch ty {
case GLenum_GL_BYTE, GLenum_GL_UNSIGNED_BYTE:
return GLint(int32(1))
case GLenum_GL_SHORT, GLenum_GL_UNSIGNED_SHORT, GLenum_GL_HALF_FLOAT, GLenum_GL_HALF_FLOAT_OES:
return GLint(int32(2))
case GLenum_GL_INT, GLenum_GL_UNSIGNED_INT, GLenum_GL_FLOAT, GLenum_GL_FIXED:
return GLint(int32(4))
case GLenum_GL_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV:
return GLint(int32(4))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ty, ϟa))
return result
}
}(), nil
}
func subReadVertexArrays(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, firstindex uint32, indexcount uint32, instancecount uint32) error {
if ((indexcount) > (uint32(0))) && ((instancecount) > (uint32(0))) {
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
vao := ctx.Instances.VertexArrays.Get(VertexArrayId(uint32(0)))
for i := AttributeLocation(uint32(0)); i < AttributeLocation(ctx.Constants.MaxVertexAttribs); i++ {
arr := vao.VertexAttributeArrays.Get(i)
if (arr.Enabled) == (GLboolean_GL_TRUE) {
binding := vao.VertexBufferBindings.Get(arr.Binding)
if ((binding.Buffer) == (BufferId(uint32(0)))) && ((arr.Pointer) != (VertexPointer(Voidᶜᵖ{}))) {
stride := binding.Stride
_res_0, ϟerr := subVertexAttribTypeSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, arr.Type)
if ϟerr != nil {
return ϟerr
}
size := (_res_0) * (arr.Size)
divisor := uint32(binding.Divisor)
if (divisor) == (uint32(0)) {
for v := firstindex; v < (firstindex)+(indexcount); v++ {
offset := (GLint(stride)) * (GLint(v))
arr.Pointer.Slice(uint64(offset), uint64((offset)+(size)), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
} else {
last_instance := (instancecount) - (uint32(1))
last_index := (last_instance) / (divisor)
for v := uint32(0); v < (last_index)+(uint32(1)); v++ {
offset := (GLint(stride)) * (GLint(v))
arr.Pointer.Slice(uint64(offset), uint64((offset)+(size)), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
}
}
}
}
}
}
return nil
}
func subBindVertexArray(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, array VertexArrayId) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.VertexArrays.Contains(array)) {
_res_0, ϟerr := subNewVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx)
if ϟerr != nil {
return ϟerr
}
ctx.Instances.VertexArrays[array] = _res_0
}
ctx.BoundVertexArray = array
return nil
}
func subBindVertexBuffer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, bindingindex VertexBufferBindingIndex, buffer BufferId, offset GLintptr, stride GLsizei) error {
if (offset) < (GLintptr(int32(0))) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueNeg("offset", int64(offset))); ϟerr != nil {
return ϟerr
}
}
if (stride) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueNeg("stride", int64(stride))); ϟerr != nil {
return ϟerr
}
}
_res_0, ϟerr := subVersionGreaterOrEqual(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, GLint(int32(3)), GLint(int32(1)))
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if (int64(bindingindex)) >= (int64(ctx.Constants.MaxVertexAttribBindings)) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueGeLimit("binding index", "GL_MAX_VERTEX_ATTRIB_BINDINGS", int64(bindingindex), int64(ctx.Constants.MaxVertexAttribBindings))); ϟerr != nil {
return ϟerr
}
}
if (int64(stride)) >= (int64(ctx.Constants.MaxVertexAttribStride)) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueGeLimit("stride", "GL_MAX_VERTEX_ATTRIB_STRIDE", int64(stride), int64(ctx.Constants.MaxVertexAttribStride))); ϟerr != nil {
return ϟerr
}
}
}
if !(ctx.Instances.Buffers.Contains(buffer)) {
ctx.Instances.Buffers[buffer] = &Buffer{Size: GLsizeiptr(int32(0)), Usage: GLenum_GL_STATIC_DRAW, Mapped: GLboolean_GL_FALSE, MapPointer: U8ᵖ{}, MapOffset: GLintptr(int32(0)), MapLength: GLsizeiptr(int32(0))}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
binding := vao.VertexBufferBindings.Get(bindingindex)
binding.Buffer = buffer
binding.Offset = offset
binding.Stride = stride
return nil
}
func subDeleteVertexArrays(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, count GLsizei, arrays VertexArrayIdᶜᵖ) error {
if (count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
a := arrays.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
for i := GLsizei(int32(0)); i < count; i++ {
id := a.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (VertexArrayId(uint32(0))) {
if ctx.Instances.VertexArrays.Contains(id) {
delete(ctx.Instances.VertexArrays, id)
if (ctx.BoundVertexArray) == (id) {
ctx.BoundVertexArray = VertexArrayId(uint32(0))
}
}
}
}
return nil
}
func subGenVertexArrays(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, count GLsizei, arrays VertexArrayIdᵖ) error {
if (count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
a := arrays.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs)
for i := GLsizei(int32(0)); i < count; i++ {
id := VertexArrayId(arrays.Slice(uint64(GLsizei(int32(0))), uint64(count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
a.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
func subIsVertexArray(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, array VertexArrayId) (GLboolean, error) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return GLboolean(uint8(0)), ϟerr
}
return func() GLboolean {
if ((array) != (VertexArrayId(uint32(0)))) && (ctx.Instances.VertexArrays.Contains(array)) {
return 1
} else {
return 0
}
}(), nil
}
func subVertexAttribF(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location AttributeLocation, value Vec4f) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (location) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
vals := MakeVec4fˢ(uint64(1), ϟs)
vals.Index(uint64(0), ϟs).Write(ϟctx, value, ϟa, ϟs, ϟd, ϟb)
ctx.VertexAttributes[location] = VertexAttributeValue{Value: AsU8ˢ(vals, ϟs)}
return nil
}
func subVertexAttribBinding(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, index AttributeLocation, bindingindex VertexBufferBindingIndex) error {
_res_0, ϟerr := subVersionGreaterOrEqual(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, GLint(int32(3)), GLint(int32(1)))
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if (int64(index)) > (int64(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueGeLimit("index", "GL_MAX_VERTEX_ATTRIBS", int64(index), int64(ctx.Constants.MaxVertexAttribs))); ϟerr != nil {
return ϟerr
}
}
if (int64(bindingindex)) > (int64(ctx.Constants.MaxVertexAttribBindings)) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueGeLimit("binding_index", "GL_MAX_VERTEX_ATTRIB_BINDINGS", int64(bindingindex), int64(ctx.Constants.MaxVertexAttribBindings))); ϟerr != nil {
return ϟerr
}
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexAttributeArrays.Get(index).Binding = bindingindex
return nil
}
func subVertexAttribDivisor(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, index AttributeLocation, divisor GLuint) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
binding_index := VertexBufferBindingIndex(index)
if ϟerr := subVertexAttribBinding(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, index, binding_index); ϟerr != nil {
return ϟerr
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexBufferBindings.Get(binding_index).Divisor = divisor
return nil
}
func subVertexAttribFormat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, index AttributeLocation, size GLint, ty GLenum, normalized GLboolean, relativeOffset GLuint, integer bool) error {
if (int64(index)) >= (int64(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValueMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrValueGeLimit("index", "GL_MAX_VERTEX_ATTRIBS", int64(index), int64(ctx.Constants.MaxVertexAttribs))); ϟerr != nil {
return ϟerr
}
}
if !(((GLint(int32(1))) <= (size)) && ((size) <= (GLint(int32(4))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if integer {
switch ty {
case GLenum_GL_BYTE, GLenum_GL_INT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_SHORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
} else {
switch ty {
case GLenum_GL_BYTE, GLenum_GL_FIXED, GLenum_GL_FLOAT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_SHORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_HALF_FLOAT_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_vertex_half_float); ϟerr != nil {
return ϟerr
}
case GLenum_GL_HALF_FLOAT, GLenum_GL_INT, GLenum_GL_UNSIGNED_INT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV:
if (size) != (GLint(int32(4))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty); ϟerr != nil {
return ϟerr
}
}
}
_res_0, ϟerr := subVersionGreaterOrEqual(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, GLint(int32(3)), GLint(int32(1)))
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if (relativeOffset) > (GLuint(ctx.Constants.MaxVertexAttribRelativeOffset)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
format := vao.VertexAttributeArrays.Get(index)
format.Size = size
format.Type = ty
if !(integer) {
format.Normalized = normalized
}
format.RelativeOffset = relativeOffset
format.Integer = func() GLboolean {
if integer {
return 1
} else {
return 0
}
}()
return nil
}
func subVertexAttribI(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location AttributeLocation, value Vec4i) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (location) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
vals := MakeVec4iˢ(uint64(1), ϟs)
vals.Index(uint64(0), ϟs).Write(ϟctx, value, ϟa, ϟs, ϟd, ϟb)
ctx.VertexAttributes[location] = VertexAttributeValue{Value: AsU8ˢ(vals, ϟs)}
return nil
}
func subVertexAttribPointer(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, index AttributeLocation, size GLint, ty GLenum, normalized GLboolean, stride GLsizei, pointer VertexPointer, integer bool) error {
boundArrayBuffer := ctx.BoundBuffers.ArrayBuffer
if ((ctx.BoundVertexArray) != (VertexArrayId(uint32(0)))) && (((boundArrayBuffer) == (BufferId(uint32(0)))) && ((pointer) != (VertexPointer(Voidᶜᵖ{})))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subVertexAttribFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, index, size, ty, normalized, GLuint(uint32(0)), integer); ϟerr != nil {
return ϟerr
}
binding_index := VertexBufferBindingIndex(index)
if ϟerr := subVertexAttribBinding(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, index, binding_index); ϟerr != nil {
return ϟerr
}
vertexTypeSize, ϟerr := subVertexAttribTypeSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ty)
if ϟerr != nil {
return ϟerr
}
effectiveStride := func() (result GLsizei) {
switch (stride) != (GLsizei(int32(0))) {
case true:
return stride
case false:
return GLsizei((vertexTypeSize) * (size))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (stride) != (GLsizei(int32(0))), ϟa))
return result
}
}()
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexAttributeArrays.Get(index).Stride = stride
vao.VertexAttributeArrays.Get(index).Pointer = pointer
if ((ctx.BoundVertexArray) == (VertexArrayId(uint32(0)))) && ((boundArrayBuffer) == (BufferId(uint32(0)))) {
if ϟerr := subBindVertexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, binding_index, BufferId(uint32(0)), GLintptr(int32(0)), effectiveStride); ϟerr != nil {
return ϟerr
}
} else {
offset := GLintptr(uint64(pointer.Address))
if ϟerr := subBindVertexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, binding_index, boundArrayBuffer, offset, effectiveStride); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subMinRequiredVersion(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, requiredMajor GLint, requiredMinor GLint) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
major := ctx.Constants.MajorVersion
minor := ctx.Constants.MinorVersion
if ((major) < (requiredMajor)) || (((major) == (requiredMajor)) && ((minor) < (requiredMinor))) {
if ϟerr := subGlErrorInvalidOperationMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrWrongContextVersion(uint32(requiredMajor), uint32(requiredMinor), uint32(major), uint32(minor))); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSupportsBits(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, seenBits GLbitfield, validBits GLbitfield) error {
if ((seenBits) & (validBits)) != (seenBits) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subRequiresExtension(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ext ExtensionId) error {
return nil
}
func subRequiresExtension2(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ext ExtensionId, ext2 ExtensionId) error {
return nil
}
func subRequiresExtension3(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ext ExtensionId, ext2 ExtensionId, ext3 ExtensionId) error {
return nil
}
func subGlErrorInvalidEnum(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, param GLenum) error {
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.onGlError(GLenum_GL_INVALID_ENUM))
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, messages.ErrInvalidEnumValue(uint32(0), "variable")))
return atom.ErrAborted("glErrorInvalidEnum")
}
func subGlErrorInvalidValue(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.onGlError(GLenum_GL_INVALID_VALUE))
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, messages.ErrInvalidValue("value", "variable")))
return atom.ErrAborted("glErrorInvalidValue")
}
func subGlErrorInvalidOperation(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
if ϟerr := subGlErrorInvalidOperationMsg(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, messages.ErrInvalidOperation("operation")); ϟerr != nil {
return ϟerr
}
return nil
}
func subGlErrorInvalidOperationMsg(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, m *msg.Msg) error {
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.onGlError(GLenum_GL_INVALID_OPERATION))
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, m))
return atom.ErrAborted("glErrorInvalidOperationMsg")
}
func subGlErrorInvalidValueMsg(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, m *msg.Msg) error {
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.onGlError(GLenum_GL_INVALID_VALUE))
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, m))
return atom.ErrAborted("glErrorInvalidValueMsg")
}
func subMin(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, a int32, b int32) (int32, error) {
return func() (result int32) {
switch (a) < (b) {
case true:
return a
case false:
return b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (a) < (b), ϟa))
return result
}
}(), nil
}
func subGetContext(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) (*Context, error) {
context := ϟc.Contexts.Get(ϟc.CurrentThread)
if (context) == ((*Context)(nil)) {
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, messages.ErrNoContextBound(uint64(ϟc.CurrentThread))))
return (*Context)(nil), atom.ErrAborted("GetContext")
}
return context, nil
}
func subSetContext(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, context *Context) error {
ϟc.Contexts[ϟc.CurrentThread] = context
return nil
}
func subCreateContext(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) (*Context, error) {
identifier := ϟc.NextContextID
ϟc.NextContextID = (ϟc.NextContextID) + (ContextID(uint32(1)))
ctx := &Context{Debug: DebugState{OutputSynchronous: GLboolean_GL_FALSE}, Rasterization: RasterizationState{DepthRange: Vec2f{Elements: [2]GLfloat{GLfloat(float32(0)), GLfloat(float32(1))}}, PrimitiveBoundingBox: BoundingBox{Min: Vec4f{Elements: [4]GLfloat{GLfloat(float32(-1)), GLfloat(float32(-1)), GLfloat(float32(-1)), GLfloat(float32(1))}}, Max: Vec4f{Elements: [4]GLfloat{GLfloat(float32(1)), GLfloat(float32(1)), GLfloat(float32(1)), GLfloat(float32(1))}}}, RasterizerDiscard: GLboolean_GL_FALSE, LineWidth: GLfloat(float32(1)), CullFace: GLboolean_GL_FALSE, CullFaceMode: GLenum_GL_BACK, FrontFace: GLenum_GL_CCW, PolygonOffsetFactor: GLfloat(float32(0)), PolygonOffsetUnits: GLfloat(float32(0)), PolygonOffsetFill: GLboolean_GL_FALSE, SampleAlphaToCoverage: GLboolean_GL_FALSE, SampleCoverage: GLboolean_GL_FALSE, SampleCoverageValue: GLfloat(float32(1)), SampleCoverageInvert: GLboolean_GL_FALSE, SampleShading: GLboolean_GL_FALSE, MinSampleShadingValue: GLfloat(float32(0)), SampleMask: GLboolean_GL_FALSE, SampleMaskValue: GLuintːGLbitfieldᵐ{}}, FragmentOperations: FragmentOperationsState{Scissor: ScissorState{Test: GLboolean_GL_FALSE}, Stencil: StencilState{Test: GLboolean_GL_FALSE, Func: GLenum_GL_ALWAYS, ValueMask: GLuint(uint32(4294967295)), Ref: GLint(int32(0)), Fail: GLenum_GL_KEEP, PassDepthFail: GLenum_GL_KEEP, PassDepthPass: GLenum_GL_KEEP, BackFunc: GLenum_GL_ALWAYS, BackValueMask: GLuint(uint32(4294967295)), BackRef: GLint(int32(0)), BackFail: GLenum_GL_KEEP, BackPassDepthFail: GLenum_GL_KEEP, BackPassDepthPass: GLenum_GL_KEEP}, Depth: DepthState{Test: GLboolean_GL_FALSE, Func: GLenum_GL_LESS}, Blend: DrawBufferIndexːBlendStateᵐ{}, Dither: GLboolean_GL_TRUE, FramebufferSrgb: GLboolean_GL_TRUE}, Framebuffer: FramebufferState{ColorWritemask: DrawBufferIndexːVec4bᵐ{}, DepthWritemask: GLboolean_GL_TRUE, StencilWritemask: GLuint(uint32(4294967295)), StencilBackWritemask: GLuint(uint32(4294967295)), ColorClearValue: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, DepthClearValue: GLfloat(float32(1)), StencilClearValue: GLint(int32(0))}, BoundFramebuffers: GLenumːFramebufferIdᵐ{}, BoundRenderbuffers: GLenumːRenderbufferIdᵐ{}, BoundBuffers: BufferBindings{AtomicCounterBuffers: GLuintːBufferBindingᵐ{}, ShaderStorageBuffers: GLuintːBufferBindingᵐ{}, UniformBuffers: GLuintːBufferBindingᵐ{}}, VertexAttributes: AttributeLocationːVertexAttributeValueᵐ{}, TextureUnits: GLenumːTextureUnitʳᵐ{}, ImageUnits: GLuintːImageUnitᵐ{}, ActiveTextureUnit: GLenum_GL_TEXTURE0, PixelStorage: PixelStorageState{UnpackImageHeight: GLint(int32(0)), UnpackSkipImages: GLint(int32(0)), UnpackRowLength: GLint(int32(0)), UnpackSkipRows: GLint(int32(0)), UnpackSkipPixels: GLint(int32(0)), UnpackAlignment: GLint(int32(4)), PackImageHeight: GLint(int32(0)), PackSkipImages: GLint(int32(0)), PackRowLength: GLint(int32(0)), PackSkipRows: GLint(int32(0)), PackSkipPixels: GLint(int32(0)), PackAlignment: GLint(int32(4))}, Miscellaneous: MiscellaneousState{PatchVertices: GLint(int32(3)), PrimitiveRestartFixedIndex: GLboolean_GL_FALSE, GenerateMipmapHint: GLenum_GL_DONT_CARE, FragmentShaderDerivativeHint: GLenum_GL_DONT_CARE}, ActiveQueries: GLenumːQueryIdᵐ{}, Instances: Objects{Renderbuffers: RenderbufferIdːRenderbufferʳᵐ{}, Textures: TextureIdːTextureʳᵐ{}, Framebuffers: FramebufferIdːFramebufferʳᵐ{}, Buffers: BufferIdːBufferʳᵐ{}, Samplers: SamplerIdːSamplerʳᵐ{}, Shaders: ShaderIdːShaderʳᵐ{}, Programs: ProgramIdːProgramʳᵐ{}, Pipelines: PipelineIdːPipelineʳᵐ{}, VertexArrays: VertexArrayIdːVertexArrayʳᵐ{}, Queries: QueryIdːQueryʳᵐ{}, TransformFeedbacks: TransformFeedbackIdːTransformFeedbackʳᵐ{}, SyncObjects: GLsyncːSyncObjectʳᵐ{}}, Constants: Constants{CompressedTextureFormats: U32ːGLenumᵐ{}, Extensions: U32ːstringᵐ{}, ShaderBinaryFormats: U32ːGLenumᵐ{}, ProgramBinaryFormats: U32ːGLenumᵐ{}}}
ctx.Identifier = identifier
return ctx, nil
}
func subApplyStaticContextState(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, staticState *StaticContextState) error {
if (staticState) != ((*StaticContextState)(nil)) {
color_id := RenderbufferId(uint32(4294967295))
depth_id := RenderbufferId(uint32(4294967294))
stencil_id := RenderbufferId(uint32(4294967293))
ctx.Constants = staticState.Constants
ctx.Instances.Framebuffers[FramebufferId(uint32(0))] = &Framebuffer{Attachments: GLenumːFramebufferAttachmentᵐ{}, DrawBuffer: GLintːGLenumᵐ{}, ReadBuffer: GLenum_GL_BACK, DefaultWidth: GLint(int32(0)), DefaultHeight: GLint(int32(0)), DefaultLayers: GLint(int32(0)), DefaultSamples: GLint(int32(0)), DefaultFixedSampleLocations: GLboolean_GL_FALSE}
ctx.Instances.Buffers[BufferId(uint32(0))] = &Buffer{Size: GLsizeiptr(int32(0)), Usage: GLenum_GL_STATIC_DRAW, Mapped: GLboolean_GL_FALSE, MapPointer: U8ᵖ{}, MapOffset: GLintptr(int32(0)), MapLength: GLsizeiptr(int32(0))}
ctx.Instances.Renderbuffers[RenderbufferId(uint32(0))] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
ctx.Instances.TransformFeedbacks[TransformFeedbackId(uint32(0))] = &TransformFeedback{Buffers: GLuintːBufferBindingᵐ{}, Paused: GLboolean_GL_FALSE, Active: GLboolean_GL_FALSE}
_res_0, ϟerr := subNewVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx)
if ϟerr != nil {
return ϟerr
}
ctx.Instances.VertexArrays[VertexArrayId(uint32(0))] = _res_0
ctx.TextureUnits[GLenum_GL_TEXTURE0] = &TextureUnit{Binding2d: TextureId(uint32(0)), Binding3d: TextureId(uint32(0)), Binding2dArray: TextureId(uint32(0)), BindingBuffer: TextureId(uint32(0)), BindingCubeMap: TextureId(uint32(0)), BindingCubeMapArray: TextureId(uint32(0)), Binding2dMultisample: TextureId(uint32(0)), Binding2dMultisampleArray: TextureId(uint32(0)), BindingExternalOes: TextureId(uint32(0)), SamplerBinding: SamplerId(uint32(0))}
ctx.Instances.DefaultTextures.Texture2d = (&Texture{Kind: GLenum_GL_TEXTURE_2D, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.Texture2dArray = (&Texture{Kind: GLenum_GL_TEXTURE_2D_ARRAY, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.Texture2dMultisample = (&Texture{Kind: GLenum_GL_TEXTURE_2D_MULTISAMPLE, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.Texture2dMultisampleArray = (&Texture{Kind: GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.Texture3d = (&Texture{Kind: GLenum_GL_TEXTURE_3D, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.TextureBuffer = (&Texture{Kind: GLenum_GL_TEXTURE_BUFFER, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.TextureCubeMap = (&Texture{Kind: GLenum_GL_TEXTURE_CUBE_MAP, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.TextureCubeMapArray = (&Texture{Kind: GLenum_GL_TEXTURE_CUBE_MAP_ARRAY, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.DefaultTextures.TextureExternalOes = (&Texture{Kind: GLenum_GL_TEXTURE_EXTERNAL_OES, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
ctx.Instances.Renderbuffers[color_id] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
ctx.Instances.Renderbuffers[depth_id] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
ctx.Instances.Renderbuffers[stencil_id] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
backbuffer := ctx.Instances.Framebuffers.Get(FramebufferId(uint32(0)))
backbuffer.Attachments[GLenum_GL_COLOR_ATTACHMENT0] = FramebufferAttachment{ObjectType: GLenum_GL_RENDERBUFFER, ObjectName: GLuint(color_id), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
backbuffer.Attachments[GLenum_GL_DEPTH_ATTACHMENT] = FramebufferAttachment{ObjectType: GLenum_GL_RENDERBUFFER, ObjectName: GLuint(depth_id), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
backbuffer.Attachments[GLenum_GL_STENCIL_ATTACHMENT] = FramebufferAttachment{ObjectType: GLenum_GL_RENDERBUFFER, ObjectName: GLuint(stencil_id), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
ctx.BoundFramebuffers[GLenum_GL_DRAW_FRAMEBUFFER] = FramebufferId(uint32(0))
ctx.BoundFramebuffers[GLenum_GL_READ_FRAMEBUFFER] = FramebufferId(uint32(0))
for i := AttributeLocation(uint32(0)); i < AttributeLocation(staticState.Constants.MaxVertexAttribs); i++ {
v := MakeVec4fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(1))}}, ϟa, ϟs, ϟd, ϟb)
ctx.VertexAttributes[i] = VertexAttributeValue{Value: AsU8ˢ(v, ϟs)}
}
for i := GLint(int32(0)); i < staticState.Constants.MaxCombinedTextureImageUnits; i++ {
name := (GLenum_GL_TEXTURE0) + (GLenum(i))
ctx.TextureUnits[name] = &TextureUnit{Binding2d: TextureId(uint32(0)), Binding3d: TextureId(uint32(0)), Binding2dArray: TextureId(uint32(0)), BindingBuffer: TextureId(uint32(0)), BindingCubeMap: TextureId(uint32(0)), BindingCubeMapArray: TextureId(uint32(0)), Binding2dMultisample: TextureId(uint32(0)), Binding2dMultisampleArray: TextureId(uint32(0)), BindingExternalOes: TextureId(uint32(0)), SamplerBinding: SamplerId(uint32(0))}
}
for i := GLuint(uint32(0)); i < GLuint(staticState.Constants.MaxImageUnits); i++ {
ctx.ImageUnits[i] = ImageUnit{Name: TextureId(uint32(0)), Level: GLint(int32(0)), Layered: GLboolean_GL_FALSE, Layer: GLint(int32(0)), Access: GLenum_GL_READ_ONLY, Format: GLenum_GL_R32UI}
}
for i := DrawBufferIndex(uint32(0)); i < DrawBufferIndex(ctx.Constants.MaxDrawBuffers); i++ {
ctx.FragmentOperations.Blend[i] = BlendState{Enabled: GLboolean_GL_FALSE, SrcRgb: GLenum_GL_ONE, SrcAlpha: GLenum_GL_ONE, DstRgb: GLenum_GL_ZERO, DstAlpha: GLenum_GL_ZERO, EquationRgb: GLenum_GL_FUNC_ADD, EquationAlpha: GLenum_GL_FUNC_ADD}
ctx.Framebuffer.ColorWritemask[i] = Vec4b{Elements: [4]GLboolean{GLboolean_GL_TRUE, GLboolean_GL_TRUE, GLboolean_GL_TRUE, GLboolean_GL_TRUE}}
}
ctx.Info.Initialized = true
}
return nil
}
func subApplyDynamicContextState(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, ctx *Context, dynamicState *DynamicContextState) error {
if (dynamicState) != ((*DynamicContextState)(nil)) {
backbuffer := ctx.Instances.Framebuffers.Get(FramebufferId(uint32(0)))
color_id := RenderbufferId(backbuffer.Attachments.Get(GLenum_GL_COLOR_ATTACHMENT0).ObjectName)
depth_id := RenderbufferId(backbuffer.Attachments.Get(GLenum_GL_DEPTH_ATTACHMENT).ObjectName)
stencil_id := RenderbufferId(backbuffer.Attachments.Get(GLenum_GL_STENCIL_ATTACHMENT).ObjectName)
color_buffer := ctx.Instances.Renderbuffers.Get(color_id)
color_buffer.Width = dynamicState.BackbufferWidth
color_buffer.Height = dynamicState.BackbufferHeight
color_buffer.InternalFormat = dynamicState.BackbufferColorFmt
ctx.Instances.Renderbuffers[color_id] = color_buffer
depth_buffer := ctx.Instances.Renderbuffers.Get(depth_id)
depth_buffer.Width = dynamicState.BackbufferWidth
depth_buffer.Height = dynamicState.BackbufferHeight
depth_buffer.InternalFormat = dynamicState.BackbufferDepthFmt
ctx.Instances.Renderbuffers[depth_id] = depth_buffer
stencil_buffer := ctx.Instances.Renderbuffers.Get(stencil_id)
stencil_buffer.Width = dynamicState.BackbufferWidth
stencil_buffer.Height = dynamicState.BackbufferHeight
stencil_buffer.InternalFormat = dynamicState.BackbufferStencilFmt
ctx.Instances.Renderbuffers[stencil_id] = stencil_buffer
if dynamicState.ResetViewportScissor {
ctx.FragmentOperations.Scissor.Box.Width = dynamicState.BackbufferWidth
ctx.FragmentOperations.Scissor.Box.Height = dynamicState.BackbufferHeight
ctx.Rasterization.Viewport.Width = dynamicState.BackbufferWidth
ctx.Rasterization.Viewport.Height = dynamicState.BackbufferHeight
}
ctx.Info.PreserveBuffersOnSwap = dynamicState.PreserveBuffersOnSwap
}
return nil
}
func subIndexSize(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, indicestype GLenum) (uint32, error) {
return func() (result uint32) {
switch indicestype {
case GLenum_GL_UNSIGNED_BYTE:
return uint32(1)
case GLenum_GL_UNSIGNED_SHORT:
return uint32(2)
case GLenum_GL_UNSIGNED_INT:
return uint32(4)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", indicestype, ϟa))
return result
}
}(), nil
}
func subErrorGLES10notSupported(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder) error {
(externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.onGlError(GLenum_GL_INVALID_OPERATION))
return atom.ErrAborted("errorGLES10notSupported")
}
func subGetnUniformfv_GLint__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, bufSize GLsizei, values GLintᵖ) error {
_ = program
_ = location
Charᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(bufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subGetnUniformfv_GLuint__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, bufSize GLsizei, values GLuintᵖ) error {
_ = program
_ = location
Charᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(bufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subProgramUniformv_GLfloat__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLfloatˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_GLint__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLintˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_GLuint__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLuintˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec2fˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec2i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec2iˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec2u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec2uˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec3fˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec3i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec3iˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec3u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec3uˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec4fˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec4i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec4iˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformv_Vec4u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values Vec4uˢ, ty GLenum) error {
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat2fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat2x3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat2x3fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat2x4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat2x4fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat3fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat3x2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat3x2fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat3x4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat3x4fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat4fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat4x2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat4x2fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subProgramUniformMatrixv_Mat4x3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, transpose GLboolean, values Mat4x3fˢ, ty GLenum) error {
_ = transpose
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, program, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat2x3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat2x3fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat2x4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat2x4fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat3x2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat3x2fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat3x4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat3x4fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat4x2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat4x2fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat4x3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat4x3fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetStateVariable_GLint64(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, name GLenum, isIndexed bool, index GLuint, v GLint64ᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch name {
case GLenum_GL_ACTIVE_TEXTURE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ActiveTextureUnit), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.AliasedLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Constants.AliasedLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_POINT_SIZE_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.AliasedPointSizeRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Constants.AliasedPointSizeRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALPHA_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.ArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ATOMIC_COUNTER_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.AtomicCounterBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_BLEND:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).Enabled), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.BlendColor.Red), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.BlendColor.Green), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.BlendColor.Blue), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.BlendColor.Alpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).DstAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).DstRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).EquationAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).EquationRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).SrcAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Blend.Get(i).SrcRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLUE_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorClearValue.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorClearValue.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorClearValue.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorClearValue.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
i := DrawBufferIndex(index)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.CompressedTextureFormats)), ϟs)
{
for i, f := range ctx.Constants.CompressedTextureFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint64(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_CONTEXT_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.ContextFlags), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CONTEXT_ROBUST_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_READ_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.CopyReadBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_WRITE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.CopyWriteBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.CullFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.CullFaceMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CURRENT_PROGRAM:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundProgram), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.DepthClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Depth.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.DepthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.DepthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Depth.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.DepthWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DISPATCH_INDIRECT_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.DispatchIndirectBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DITHER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Dither), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER0, GLenum_GL_DRAW_BUFFER1, GLenum_GL_DRAW_BUFFER2, GLenum_GL_DRAW_BUFFER3, GLenum_GL_DRAW_BUFFER4, GLenum_GL_DRAW_BUFFER5, GLenum_GL_DRAW_BUFFER6, GLenum_GL_DRAW_BUFFER7, GLenum_GL_DRAW_BUFFER8, GLenum_GL_DRAW_BUFFER9, GLenum_GL_DRAW_BUFFER10, GLenum_GL_DRAW_BUFFER11, GLenum_GL_DRAW_BUFFER12, GLenum_GL_DRAW_BUFFER13, GLenum_GL_DRAW_BUFFER14, GLenum_GL_DRAW_BUFFER15:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_DRAW_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(framebuffer.DrawBuffer.Get(GLint((name)-(GLenum_GL_DRAW_BUFFER0)))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundFramebuffers.Get(GLenum_GL_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ELEMENT_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.FragmentInterpolationOffsetBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRONT_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.FrontFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GENERATE_MIPMAP_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Miscellaneous.GenerateMipmapHint), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GREEN_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_BINDING_NAME:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Name), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Level), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYERED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Layered), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Layer), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Access), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.ImageUnits.Get(index).Format), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMPLEMENTATION_COLOR_READ_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMPLEMENTATION_COLOR_READ_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LAYER_PROVOKING_VERTEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.LayerProvokingVertex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LINE_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.LineWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.PrimitiveRestartForPatchesSupported), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAJOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MajorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_3D_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.Max3dTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ARRAY_TEXTURE_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxArrayTextureLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxAtomicCounterBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxAtomicCounterBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_ATTACHMENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxColorAttachments), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxColorTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEPTH_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxDepthTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedFragmentUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedShaderOutputResources), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedVertexUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCombinedImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeSharedMemorySize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_COUNT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeWorkGroupCount.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeWorkGroupInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxComputeWorkGroupSize.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxCubeMapTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxDebugGroupStackDepth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxDebugLoggedMessages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxDebugMessageLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DRAW_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxDrawBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENT_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxElementIndex, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_INDICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxElementsIndices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxElementsVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MinProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFragmentUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFramebufferHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFramebufferLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFramebufferSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxFramebufferWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryOutputVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryShaderInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_INTEGER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxIntegerSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_LABEL_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxLabelLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_RENDERBUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxRenderbufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLE_MASK_WORDS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxSampleMaskWords), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SERVER_WAIT_TIMEOUT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxServerWaitTimeout, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxShaderStorageBlockSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxShaderStorageBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_GEN_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessGenLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxPatchVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_PATCH_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTessPatchComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTextureBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_LOD_BIAS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTextureLodBias), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTransformFeedbackInterleavedComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTransformFeedbackSeparateAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTransformFeedbackSeparateComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxUniformBlockSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxUniformBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_LOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxUniformLocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVaryingComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVaryingVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAttribBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAttribStride), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAttribRelativeOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxVertexUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VIEWPORT_DIMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxViewportDims.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxViewportDims.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MinFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MinProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_SAMPLE_SHADING_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.MinSampleShadingValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MINOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MinorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MultisampleLineWidthGranularity), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(int64(len(ctx.Constants.CompressedTextureFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_EXTENSIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(int64(len(ctx.Constants.Extensions))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(int64(len(ctx.Constants.ProgramBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(int64(len(ctx.Constants.ShaderBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.PackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_PACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.PixelPackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_UNPACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.PixelUnpackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FACTOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.PolygonOffsetFactor), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FILL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.PolygonOffsetFill), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.PolygonOffsetUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_BOUNDING_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(8), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Miscellaneous.PrimitiveRestartFixedIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ProgramBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ProgramBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint64(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_PROGRAM_PIPELINE_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RASTERIZER_DISCARD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.RasterizerDiscard), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RED_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RENDERBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundRenderbuffers.Get(GLenum_GL_RENDERBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RESET_NOTIFICATION_STRATEGY:
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.SampleAlphaToCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.SampleCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_INVERT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.SampleCoverageInvert), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.SampleCoverageValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_SHADING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Scissor.Box.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Scissor.Box.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Scissor.Box.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Scissor.Box.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Scissor.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ShaderBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ShaderBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint64(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_SHADER_COMPILER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.ShaderCompiler), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.ShaderStorageBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.ShaderStorageBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_SHADER_STORAGE_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_STENCIL_BACK_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackPassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackPassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackRef), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.BackValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.StencilBackWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.StencilClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.Fail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.PassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.PassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.Ref), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.FragmentOperations.Stencil.ValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Framebuffer.StencilWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SUBPIXEL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.SubpixelBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_EXTERNAL_OES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingExternalOes), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisample), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisampleArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding3d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMap), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMapArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.TextureBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_ACTIVE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(_res_0.Active), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundTransformFeedback), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(_res_0.Buffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.TransformFeedbackBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(_res_0.Buffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(_res_0.Buffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_PAUSED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(_res_0.Paused), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.UniformBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.UniformBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.UniformBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.UniformBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNIFORM_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundBuffers.UniformBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNPACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.PixelStorage.UnpackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_ARRAY_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.BoundVertexArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_BINDING_DIVISOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Divisor), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Offset), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Stride), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VIEWPORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.Viewport.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.Viewport.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.Viewport.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint64(ctx.Rasterization.Viewport.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(ctx.Constants.MaxTextureMaxAnisotropyExt), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GPU_DISJOINT_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetSamplerParameterv_GLint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLintᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAG_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.MinLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.MaxLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, GLint(s.BorderColor.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, GLint(s.BorderColor.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, GLint(s.BorderColor.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, GLint(s.BorderColor.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(s.MaxAnisotropy), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetSamplerParameterv_GLuint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLuintᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAG_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.MinLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.MaxLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.BorderColor.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, GLuint(s.BorderColor.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, GLuint(s.BorderColor.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, GLuint(s.BorderColor.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(s.MaxAnisotropy), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetTexParameter_GLint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, parameter GLenum, params GLintᵖ) error {
switch target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP:
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch parameter {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).BaseLevel, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_FORMAT:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).ImmutableFormat), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).MaxLevel, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).MaxLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).MinLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).SwizzleA), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).SwizzleB), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).SwizzleG), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).SwizzleR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).DepthStencilTextureMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_LEVELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).ImmutableLevels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).BorderColor.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).BorderColor.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).BorderColor.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).BorderColor.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(t.OnAccess(ϟs).MaxAnisotropy), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetTexParameter_GLuint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, parameter GLenum, params GLuintᵖ) error {
switch target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP:
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch parameter {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).BaseLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_FORMAT:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).ImmutableFormat), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MaxLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MaxLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MinLod), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).SwizzleA), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).SwizzleB), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).SwizzleG), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).SwizzleR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).DepthStencilTextureMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_LEVELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).ImmutableLevels, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).BorderColor.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).BorderColor.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).BorderColor.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).BorderColor.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(t.OnAccess(ϟs).MaxAnisotropy), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSamplerParameterv_GLint__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLintᶜᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
s.CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
s.CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_FILTER:
s.MinFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAG_FILTER:
s.MagFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_LOD:
s.MinLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAX_LOD:
s.MaxLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_R:
s.WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_S:
s.WrapS = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_T:
s.WrapT = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
s.MaxAnisotropy = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSamplerParameterv_GLuint__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLuintᶜᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
s.CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
s.CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_FILTER:
s.MinFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAG_FILTER:
s.MagFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_LOD:
s.MinLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAX_LOD:
s.MaxLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_R:
s.WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_S:
s.WrapS = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_T:
s.WrapT = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
s.MaxAnisotropy = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexParameterv_GLint__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLintᶜᵖ) error {
if (target) == (GLenum_GL_TEXTURE_BUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch pname {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
magFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch magFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, magFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MagFilter = magFilter
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
minFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch minFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR, GLenum_GL_NEAREST_MIPMAP_NEAREST, GLenum_GL_LINEAR_MIPMAP_NEAREST, GLenum_GL_NEAREST_MIPMAP_LINEAR, GLenum_GL_LINEAR_MIPMAP_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, minFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MinFilter = minFilter
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapS = _res_0
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapT = _res_0
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
baseLevel := params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (baseLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).BaseLevel = baseLevel
case GLenum_GL_TEXTURE_COMPARE_FUNC:
t.OnAccess(ϟs).CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
t.OnAccess(ϟs).CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
maxLevel := params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (maxLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MaxLevel = maxLevel
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MinLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleA = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleB = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleG = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleR = _res_0
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).DepthStencilTextureMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxAnisotropy = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_SRGB_DECODE_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_sRGB_decode); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexParameterv_GLuint__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLuintᶜᵖ) error {
if (target) == (GLenum_GL_TEXTURE_BUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch pname {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
magFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch magFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, magFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MagFilter = magFilter
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
minFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch minFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR, GLenum_GL_NEAREST_MIPMAP_NEAREST, GLenum_GL_LINEAR_MIPMAP_NEAREST, GLenum_GL_NEAREST_MIPMAP_LINEAR, GLenum_GL_LINEAR_MIPMAP_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, minFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MinFilter = minFilter
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapS = _res_0
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapT = _res_0
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
baseLevel := GLint(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
if (baseLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).BaseLevel = baseLevel
case GLenum_GL_TEXTURE_COMPARE_FUNC:
t.OnAccess(ϟs).CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
t.OnAccess(ϟs).CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
maxLevel := GLint(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
if (maxLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MaxLevel = maxLevel
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MinLod = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleA = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleB = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleG = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleR = _res_0
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).DepthStencilTextureMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxAnisotropy = GLfloat(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_SRGB_DECODE_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_sRGB_decode); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subMax_GLsizei(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, a GLsizei, b GLsizei) (GLsizei, error) {
return func() (result GLsizei) {
switch (a) > (b) {
case true:
return a
case false:
return b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (a) > (b), ϟa))
return result
}
}(), nil
}
func subGetBufferParameter_GLint64(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, parameter GLenum, value GLint64ᵖ) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch parameter {
case GLenum_GL_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.Size), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_USAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.Usage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_ACCESS_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.AccessFlags), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAPPED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.Mapped), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAP_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.MapLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAP_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint64(b.MapOffset), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetBufferParameter_GLint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, parameter GLenum, value GLintᵖ) error {
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch parameter {
case GLenum_GL_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.Size), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_USAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.Usage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_ACCESS_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.AccessFlags), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAPPED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.Mapped), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAP_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.MapLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BUFFER_MAP_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(b.MapOffset), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetnUniformfv_GLfloat__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, bufSize GLsizei, values GLfloatᵖ) error {
_ = program
_ = location
Charᵖ(values).Slice(uint64(GLsizei(int32(0))), uint64(bufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subGetUniformv_GLfloat__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLfloatᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, program); ϟerr != nil {
return ϟerr
}
_ = program
_ = location
values.Slice(uint64(0), uint64(16), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subGetUniformv_GLint__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLintᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, program); ϟerr != nil {
return ϟerr
}
_ = program
_ = location
values.Slice(uint64(0), uint64(16), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subGetUniformv_GLuint__P(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, program ProgramId, location UniformLocation, values GLuintᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, program); ϟerr != nil {
return ϟerr
}
_ = program
_ = location
values.Slice(uint64(0), uint64(16), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
func subUniformv_GLfloat__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values GLfloatˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_GLint__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values GLintˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_GLuint__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values GLuintˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec2fˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec2i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec2iˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec2u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec2uˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec3fˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec3i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec3iˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec3u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec3uˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec4fˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec4i__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec4iˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformv_Vec4u__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, values Vec4uˢ, ty GLenum) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat2f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat2fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat3f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat3fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subUniformMatrixv_Mat4f__S(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, location UniformLocation, transpose GLboolean, values Mat4fˢ, ty GLenum) error {
_ = transpose
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetProgramUniform(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx.BoundProgram, location, AsU8ˢ(values, ϟs), ty); ϟerr != nil {
return ϟerr
}
return nil
}
func subGetStateVariable_GLboolean(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, name GLenum, isIndexed bool, index GLuint, v GLbooleanᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch name {
case GLenum_GL_ACTIVE_TEXTURE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ActiveTextureUnit), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.AliasedLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Constants.AliasedLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_POINT_SIZE_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.AliasedPointSizeRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Constants.AliasedPointSizeRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALPHA_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.ArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ATOMIC_COUNTER_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.AtomicCounterBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_BLEND:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Blend.Get(i).Enabled, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.BlendColor.Red), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.BlendColor.Green), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.BlendColor.Blue), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.BlendColor.Alpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).DstAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).DstRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).EquationAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).EquationRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).SrcAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Blend.Get(i).SrcRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLUE_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.ColorClearValue.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.ColorClearValue.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.ColorClearValue.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.ColorClearValue.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
i := DrawBufferIndex(index)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(2)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(3)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.CompressedTextureFormats)), ϟs)
{
for i, f := range ctx.Constants.CompressedTextureFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLboolean(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_CONTEXT_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.ContextFlags), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CONTEXT_ROBUST_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_READ_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.CopyReadBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_WRITE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.CopyWriteBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.CullFace, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.CullFaceMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CURRENT_PROGRAM:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundProgram), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.DepthClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Depth.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.DepthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.DepthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Depth.Test, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Framebuffer.DepthWritemask, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DISPATCH_INDIRECT_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.DispatchIndirectBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DITHER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Dither, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER0, GLenum_GL_DRAW_BUFFER1, GLenum_GL_DRAW_BUFFER2, GLenum_GL_DRAW_BUFFER3, GLenum_GL_DRAW_BUFFER4, GLenum_GL_DRAW_BUFFER5, GLenum_GL_DRAW_BUFFER6, GLenum_GL_DRAW_BUFFER7, GLenum_GL_DRAW_BUFFER8, GLenum_GL_DRAW_BUFFER9, GLenum_GL_DRAW_BUFFER10, GLenum_GL_DRAW_BUFFER11, GLenum_GL_DRAW_BUFFER12, GLenum_GL_DRAW_BUFFER13, GLenum_GL_DRAW_BUFFER14, GLenum_GL_DRAW_BUFFER15:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_DRAW_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(framebuffer.DrawBuffer.Get(GLint((name)-(GLenum_GL_DRAW_BUFFER0)))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundFramebuffers.Get(GLenum_GL_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ELEMENT_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.FragmentInterpolationOffsetBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRONT_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.FrontFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GENERATE_MIPMAP_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Miscellaneous.GenerateMipmapHint), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GREEN_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_BINDING_NAME:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ImageUnits.Get(index).Name), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ImageUnits.Get(index).Level), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYERED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.ImageUnits.Get(index).Layered, ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ImageUnits.Get(index).Layer), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ImageUnits.Get(index).Access), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.ImageUnits.Get(index).Format), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMPLEMENTATION_COLOR_READ_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMPLEMENTATION_COLOR_READ_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LAYER_PROVOKING_VERTEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.LayerProvokingVertex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LINE_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.LineWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.PrimitiveRestartForPatchesSupported, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAJOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MajorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_3D_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.Max3dTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ARRAY_TEXTURE_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxArrayTextureLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxAtomicCounterBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxAtomicCounterBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_ATTACHMENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxColorAttachments), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxColorTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEPTH_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxDepthTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedShaderOutputResources), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCombinedImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeSharedMemorySize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_COUNT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeWorkGroupCount.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeWorkGroupInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxComputeWorkGroupSize.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxCubeMapTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxDebugGroupStackDepth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxDebugLoggedMessages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxDebugMessageLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DRAW_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxDrawBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENT_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxElementIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_INDICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxElementsIndices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxElementsVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MinProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFragmentUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFramebufferHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFramebufferLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFramebufferSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxFramebufferWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryOutputVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryShaderInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_INTEGER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxIntegerSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_LABEL_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxLabelLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_RENDERBUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxRenderbufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLE_MASK_WORDS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxSampleMaskWords), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SERVER_WAIT_TIMEOUT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxServerWaitTimeout), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxShaderStorageBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxShaderStorageBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_GEN_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessGenLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxPatchVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_PATCH_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTessPatchComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTextureBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_LOD_BIAS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTextureLodBias), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTransformFeedbackInterleavedComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTransformFeedbackSeparateAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTransformFeedbackSeparateComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxUniformBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxUniformBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_LOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxUniformLocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVaryingComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVaryingVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAttribBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAttribStride), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAttribRelativeOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxVertexUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VIEWPORT_DIMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxViewportDims.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxViewportDims.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MinFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MinProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_SAMPLE_SHADING_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.MinSampleShadingValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MINOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MinorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MultisampleLineWidthGranularity), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(int32(len(ctx.Constants.CompressedTextureFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_EXTENSIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(int32(len(ctx.Constants.Extensions))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(int32(len(ctx.Constants.ProgramBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(int32(len(ctx.Constants.ShaderBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.PackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_PACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.PixelPackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_UNPACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.PixelUnpackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FACTOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.PolygonOffsetFactor), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FILL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.PolygonOffsetFill, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.PolygonOffsetUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_BOUNDING_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(8), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Miscellaneous.PrimitiveRestartFixedIndex, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ProgramBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ProgramBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLboolean(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_PROGRAM_PIPELINE_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RASTERIZER_DISCARD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.RasterizerDiscard, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RED_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RENDERBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundRenderbuffers.Get(GLenum_GL_RENDERBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RESET_NOTIFICATION_STRATEGY:
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.SampleAlphaToCoverage, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.SampleCoverage, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_INVERT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.SampleCoverageInvert, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.SampleCoverageValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_SHADING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Scissor.Box.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Scissor.Box.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Scissor.Box.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Scissor.Box.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Scissor.Test, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ShaderBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ShaderBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLboolean(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_SHADER_COMPILER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.ShaderCompiler, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.ShaderStorageBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.ShaderStorageBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_SHADER_STORAGE_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_STENCIL_BACK_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackPassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackPassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackRef), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.BackValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.StencilBackWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.StencilClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.Fail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.PassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.PassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.Ref), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Stencil.Test, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.FragmentOperations.Stencil.ValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Framebuffer.StencilWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SUBPIXEL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.SubpixelBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_EXTERNAL_OES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingExternalOes), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisample), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisampleArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding3d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMap), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMapArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.TextureBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_ACTIVE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, _res_0.Active, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundTransformFeedback), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(_res_0.Buffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.TransformFeedbackBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(_res_0.Buffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(_res_0.Buffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_PAUSED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, _res_0.Paused, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.UniformBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.UniformBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.UniformBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.UniformBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNIFORM_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundBuffers.UniformBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNPACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.PixelStorage.UnpackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_ARRAY_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.BoundVertexArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_BINDING_DIVISOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Divisor), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Offset), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Stride), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VIEWPORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.Viewport.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.Viewport.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.Viewport.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLboolean(ctx.Rasterization.Viewport.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLboolean(ctx.Constants.MaxTextureMaxAnisotropyExt), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GPU_DISJOINT_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetStateVariable_GLfloat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, name GLenum, isIndexed bool, index GLuint, v GLfloatᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch name {
case GLenum_GL_ACTIVE_TEXTURE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ActiveTextureUnit), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.AliasedLineWidthRange.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Constants.AliasedLineWidthRange.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_POINT_SIZE_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.AliasedPointSizeRange.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Constants.AliasedPointSizeRange.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALPHA_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.ArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ATOMIC_COUNTER_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.AtomicCounterBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_BLEND:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).Enabled), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.BlendColor.Red, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.FragmentOperations.BlendColor.Green, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, ctx.FragmentOperations.BlendColor.Blue, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, ctx.FragmentOperations.BlendColor.Alpha, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).DstAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).DstRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).EquationAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).EquationRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).SrcAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Blend.Get(i).SrcRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLUE_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Framebuffer.ColorClearValue.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Framebuffer.ColorClearValue.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, ctx.Framebuffer.ColorClearValue.Elements[uint64(2)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, ctx.Framebuffer.ColorClearValue.Elements[uint64(3)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
i := DrawBufferIndex(index)
s.Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.CompressedTextureFormats)), ϟs)
{
for i, f := range ctx.Constants.CompressedTextureFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLfloat(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_CONTEXT_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.ContextFlags), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CONTEXT_ROBUST_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_READ_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.CopyReadBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_WRITE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.CopyWriteBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.CullFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.CullFaceMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CURRENT_PROGRAM:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundProgram), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Framebuffer.DepthClearValue, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Depth.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.DepthRange.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Rasterization.DepthRange.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Depth.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.DepthWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DISPATCH_INDIRECT_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.DispatchIndirectBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DITHER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Dither), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER0, GLenum_GL_DRAW_BUFFER1, GLenum_GL_DRAW_BUFFER2, GLenum_GL_DRAW_BUFFER3, GLenum_GL_DRAW_BUFFER4, GLenum_GL_DRAW_BUFFER5, GLenum_GL_DRAW_BUFFER6, GLenum_GL_DRAW_BUFFER7, GLenum_GL_DRAW_BUFFER8, GLenum_GL_DRAW_BUFFER9, GLenum_GL_DRAW_BUFFER10, GLenum_GL_DRAW_BUFFER11, GLenum_GL_DRAW_BUFFER12, GLenum_GL_DRAW_BUFFER13, GLenum_GL_DRAW_BUFFER14, GLenum_GL_DRAW_BUFFER15:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_DRAW_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(framebuffer.DrawBuffer.Get(GLint((name)-(GLenum_GL_DRAW_BUFFER0)))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundFramebuffers.Get(GLenum_GL_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ELEMENT_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.FragmentInterpolationOffsetBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRONT_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.FrontFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GENERATE_MIPMAP_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Miscellaneous.GenerateMipmapHint), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GREEN_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_BINDING_NAME:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Name), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Level), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYERED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Layered), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Layer), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Access), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.ImageUnits.Get(index).Format), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMPLEMENTATION_COLOR_READ_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMPLEMENTATION_COLOR_READ_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LAYER_PROVOKING_VERTEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.LayerProvokingVertex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LINE_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.LineWidth, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.PrimitiveRestartForPatchesSupported), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAJOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MajorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_3D_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.Max3dTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ARRAY_TEXTURE_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxArrayTextureLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxAtomicCounterBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxAtomicCounterBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_ATTACHMENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxColorAttachments), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxColorTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEPTH_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxDepthTextureSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedShaderOutputResources), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCombinedImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeSharedMemorySize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_COUNT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeWorkGroupCount.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeWorkGroupInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxComputeWorkGroupSize.Elements[index]), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxCubeMapTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxDebugGroupStackDepth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxDebugLoggedMessages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxDebugMessageLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DRAW_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxDrawBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENT_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxElementIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_INDICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxElementsIndices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxElementsVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentInterpolationOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MinProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxProgramTextureGatherOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFragmentUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFramebufferHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFramebufferLayers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFramebufferSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxFramebufferWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryOutputVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryShaderInvocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxGeometryUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_INTEGER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxIntegerSamples), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_LABEL_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxLabelLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_RENDERBUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxRenderbufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLE_MASK_WORDS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxSampleMaskWords), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SERVER_WAIT_TIMEOUT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxServerWaitTimeout), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxShaderStorageBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxShaderStorageBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlTotalOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessControlUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationInputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessEvaluationUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_GEN_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessGenLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxPatchVertices), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_PATCH_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTessPatchComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTextureBufferSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_LOD_BIAS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTextureLodBias, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTextureSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTransformFeedbackInterleavedComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTransformFeedbackSeparateAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxTransformFeedbackSeparateComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxUniformBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxUniformBufferBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_LOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxUniformLocations), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVaryingComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVaryingVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAtomicCounters), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAtomicCounterBuffers), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAttribBindings), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAttribStride), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAttribRelativeOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexAttribs), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexImageUniforms), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexOutputComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexShaderStorageBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexTextureImageUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexUniformBlocks), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxVertexUniformVectors), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VIEWPORT_DIMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxViewportDims.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MaxViewportDims.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MinFragmentInterpolationOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MinProgramTexelOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_SAMPLE_SHADING_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.MinSampleShadingValue, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MINOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.MinorVersion), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MultisampleLineWidthRange.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Constants.MultisampleLineWidthRange.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MultisampleLineWidthGranularity, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(int32(len(ctx.Constants.CompressedTextureFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_EXTENSIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(int32(len(ctx.Constants.Extensions))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(int32(len(ctx.Constants.ProgramBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(int32(len(ctx.Constants.ShaderBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.PackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_PACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.PixelPackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_UNPACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.PixelUnpackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FACTOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.PolygonOffsetFactor, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FILL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.PolygonOffsetFill), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.PolygonOffsetUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_BOUNDING_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(8), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Miscellaneous.PrimitiveRestartFixedIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ProgramBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ProgramBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLfloat(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_PROGRAM_PIPELINE_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RASTERIZER_DISCARD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.RasterizerDiscard), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RED_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RENDERBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundRenderbuffers.Get(GLenum_GL_RENDERBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RESET_NOTIFICATION_STRATEGY:
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.SampleAlphaToCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.SampleCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_INVERT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.SampleCoverageInvert), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.SampleCoverageValue, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_SHADING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Scissor.Box.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Scissor.Box.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Scissor.Box.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Scissor.Box.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Scissor.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ShaderBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ShaderBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLfloat(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_SHADER_COMPILER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.ShaderCompiler), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.ShaderStorageBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.ShaderStorageBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_SHADER_STORAGE_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_STENCIL_BACK_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackPassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackPassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackRef), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.BackValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.StencilBackWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.StencilClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.Fail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.PassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.PassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.Ref), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.FragmentOperations.Stencil.ValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Framebuffer.StencilWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SUBPIXEL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.SubpixelBits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_EXTERNAL_OES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingExternalOes), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisample), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisampleArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding3d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMap), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMapArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.TextureBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_ACTIVE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0.Active), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundTransformFeedback), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0.Buffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.TransformFeedbackBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0.Buffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0.Buffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_PAUSED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0.Paused), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.UniformBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.UniformBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Constants.UniformBufferOffsetAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.UniformBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNIFORM_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundBuffers.UniformBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNPACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackAlignment), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackImageHeight), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackRowLength), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackSkipImages), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackSkipPixels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.PixelStorage.UnpackSkipRows), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_ARRAY_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.BoundVertexArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_BINDING_DIVISOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Divisor), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Offset), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Stride), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VIEWPORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.Viewport.X), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.Viewport.Y), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.Viewport.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLfloat(ctx.Rasterization.Viewport.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTextureMaxAnisotropyExt, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GPU_DISJOINT_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetStateVariable_GLint(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, name GLenum, isIndexed bool, index GLuint, v GLintᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch name {
case GLenum_GL_ACTIVE_TEXTURE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ActiveTextureUnit), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.AliasedLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Constants.AliasedLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALIASED_POINT_SIZE_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.AliasedPointSizeRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Constants.AliasedPointSizeRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ALPHA_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.ArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ATOMIC_COUNTER_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.AtomicCounterBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_ATOMIC_COUNTER_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.AtomicCounterBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_BLEND:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).Enabled), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.BlendColor.Red), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.BlendColor.Green), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.BlendColor.Blue), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.BlendColor.Alpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).DstAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_DST_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).DstRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).EquationAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_EQUATION_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).EquationRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_ALPHA:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).SrcAlpha), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLEND_SRC_RGB:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
i := DrawBufferIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Blend.Get(i).SrcRgb), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_BLUE_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorClearValue.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorClearValue.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorClearValue.Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorClearValue.Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COLOR_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
i := DrawBufferIndex(index)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(2)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.ColorWritemask.Get(i).Elements[uint64(3)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.CompressedTextureFormats)), ϟs)
{
for i, f := range ctx.Constants.CompressedTextureFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_CONTEXT_FLAGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.ContextFlags, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CONTEXT_ROBUST_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_READ_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.CopyReadBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_COPY_WRITE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.CopyWriteBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.CullFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CULL_FACE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.CullFaceMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_CURRENT_PROGRAM:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundProgram), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.DepthClearValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Depth.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.DepthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Rasterization.DepthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Depth.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.DepthWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DISPATCH_INDIRECT_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.DispatchIndirectBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DITHER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Dither), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_BUFFER0, GLenum_GL_DRAW_BUFFER1, GLenum_GL_DRAW_BUFFER2, GLenum_GL_DRAW_BUFFER3, GLenum_GL_DRAW_BUFFER4, GLenum_GL_DRAW_BUFFER5, GLenum_GL_DRAW_BUFFER6, GLenum_GL_DRAW_BUFFER7, GLenum_GL_DRAW_BUFFER8, GLenum_GL_DRAW_BUFFER9, GLenum_GL_DRAW_BUFFER10, GLenum_GL_DRAW_BUFFER11, GLenum_GL_DRAW_BUFFER12, GLenum_GL_DRAW_BUFFER13, GLenum_GL_DRAW_BUFFER14, GLenum_GL_DRAW_BUFFER15:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_DRAW_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(framebuffer.DrawBuffer.Get(GLint((name)-(GLenum_GL_DRAW_BUFFER0)))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DRAW_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundFramebuffers.Get(GLenum_GL_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_ELEMENT_ARRAY_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.FragmentInterpolationOffsetBits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_FRONT_FACE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.FrontFace), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GENERATE_MIPMAP_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Miscellaneous.GenerateMipmapHint), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GREEN_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_BINDING_NAME:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ImageUnits.Get(index).Name), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.ImageUnits.Get(index).Level, ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYERED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ImageUnits.Get(index).Layered), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_LAYER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.ImageUnits.Get(index).Layer, ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_ACCESS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ImageUnits.Get(index).Access), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMAGE_BINDING_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ImageUnits.Get(index).Format), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_IMPLEMENTATION_COLOR_READ_FORMAT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMPLEMENTATION_COLOR_READ_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LAYER_PROVOKING_VERTEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.LayerProvokingVertex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_LINE_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.LineWidth), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.PrimitiveRestartForPatchesSupported), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAJOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MajorVersion, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_3D_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.Max3dTextureSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ARRAY_TEXTURE_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxArrayTextureLayers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxAtomicCounterBufferBindings, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxAtomicCounterBufferSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_ATTACHMENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxColorAttachments, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COLOR_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxColorTextureSamples, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEPTH_TEXTURE_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxDepthTextureSamples, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedComputeUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxCombinedFragmentUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedGeometryUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedTessControlUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedTessEvaluationUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedShaderOutputResources, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxCombinedVertexUniformComponents), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMBINED_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCombinedImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_SHARED_MEMORY_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeSharedMemorySize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_COUNT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeWorkGroupCount.Elements[index], ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeWorkGroupInvocations, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_COMPUTE_WORK_GROUP_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxComputeWorkGroupSize.Elements[index], ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxCubeMapTextureSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_GROUP_STACK_DEPTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxDebugGroupStackDepth, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_LOGGED_MESSAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxDebugLoggedMessages, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DEBUG_MESSAGE_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxDebugMessageLength, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_DRAW_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxDrawBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENT_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxElementIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_INDICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxElementsIndices, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_ELEMENTS_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxElementsVertices, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentInputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MinProgramTextureGatherOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxProgramTextureGatherOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFragmentUniformVectors, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFramebufferHeight, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFramebufferLayers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFramebufferSamples, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_FRAMEBUFFER_WIDTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxFramebufferWidth, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryInputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_OUTPUT_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryOutputVertices, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryShaderInvocations, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryTotalOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxGeometryUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_INTEGER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxIntegerSamples, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_LABEL_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxLabelLength, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxProgramTexelOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_RENDERBUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxRenderbufferSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLE_MASK_WORDS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxSampleMaskWords, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SERVER_WAIT_TIMEOUT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxServerWaitTimeout), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxShaderStorageBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxShaderStorageBufferBindings, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlInputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlTotalOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessControlUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationInputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessEvaluationUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_GEN_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessGenLevel, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxPatchVertices, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TESS_PATCH_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTessPatchComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTextureBufferSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_LOD_BIAS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxTextureLodBias), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTextureSize, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTransformFeedbackInterleavedComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTransformFeedbackSeparateAttribs, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxTransformFeedbackSeparateComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BLOCK_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxUniformBlockSize), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_BUFFER_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxUniformBufferBindings, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_UNIFORM_LOCATIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxUniformLocations, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVaryingComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VARYING_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVaryingVectors, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAtomicCounters, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAtomicCounterBuffers, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_BINDINGS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAttribBindings, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAttribStride, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAttribRelativeOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_ATTRIBS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexAttribs, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_IMAGE_UNIFORMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexImageUniforms, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_OUTPUT_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexOutputComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexShaderStorageBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexTextureImageUnits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_BLOCKS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexUniformBlocks, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_COMPONENTS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexUniformComponents, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VERTEX_UNIFORM_VECTORS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxVertexUniformVectors, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_VIEWPORT_DIMS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MaxViewportDims.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Constants.MaxViewportDims.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MinFragmentInterpolationOffset), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_PROGRAM_TEXEL_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MinProgramTexelOffset, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MIN_SAMPLE_SHADING_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.MinSampleShadingValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MINOR_VERSION:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.MinorVersion, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_RANGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(2), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(0)]), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, GLint(ctx.Constants.MultisampleLineWidthRange.Elements[uint64(1)]), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MultisampleLineWidthGranularity), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(int32(len(ctx.Constants.CompressedTextureFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_EXTENSIONS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(int32(len(ctx.Constants.Extensions))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(int32(len(ctx.Constants.ProgramBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_NUM_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(int32(len(ctx.Constants.ShaderBinaryFormats))), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackAlignment, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackImageHeight, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackRowLength, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackSkipImages, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackSkipPixels, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.PackSkipRows, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PATCH_VERTICES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_PACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.PixelPackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PIXEL_UNPACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.PixelUnpackBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FACTOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.PolygonOffsetFactor), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_FILL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.PolygonOffsetFill), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_POLYGON_OFFSET_UNITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.PolygonOffsetUnits), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_BOUNDING_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(8), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PRIMITIVE_RESTART_FIXED_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Miscellaneous.PrimitiveRestartFixedIndex), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_PROGRAM_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ProgramBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ProgramBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_PROGRAM_PIPELINE_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RASTERIZER_DISCARD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.RasterizerDiscard), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_READ_FRAMEBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RED_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RENDERBUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundRenderbuffers.Get(GLenum_GL_RENDERBUFFER)), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_RESET_NOTIFICATION_STRATEGY:
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.SampleAlphaToCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_BUFFERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.SampleCoverage), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_INVERT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.SampleCoverageInvert), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_COVERAGE_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Rasterization.SampleCoverageValue), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLE_SHADING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_BOX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Scissor.Box.X, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.FragmentOperations.Scissor.Box.Y, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Scissor.Box.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Scissor.Box.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SCISSOR_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Scissor.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_BINARY_FORMATS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(len(ctx.Constants.ShaderBinaryFormats)), ϟs)
{
for i, f := range ctx.Constants.ShaderBinaryFormats {
s.Index(uint64(i), ϟs).Write(ϟctx, GLint(f), ϟa, ϟs, ϟd, ϟb)
}
}
case GLenum_GL_SHADER_COMPILER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.ShaderCompiler), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.ShaderStorageBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.ShaderStorageBufferOffsetAlignment, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SHADER_STORAGE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_SHADER_STORAGE_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.ShaderStorageBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_STENCIL_BACK_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.BackFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.BackFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.BackPassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.BackPassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Stencil.BackRef, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.BackValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BACK_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.StencilBackWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_CLEAR_VALUE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Framebuffer.StencilClearValue, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.Fail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_FUNC:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.Func), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_FAIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.PassDepthFail), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_PASS_DEPTH_PASS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.PassDepthPass), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_REF:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.FragmentOperations.Stencil.Ref, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_TEST:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.Test), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_VALUE_MASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.FragmentOperations.Stencil.ValueMask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL_WRITEMASK:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Framebuffer.StencilWritemask), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_SUBPIXEL_BITS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.SubpixelBits, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_EXTERNAL_OES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingExternalOes), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisample), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding2dMultisampleArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Binding3d), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingBuffer), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMap), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.TextureUnits.Get(ctx.ActiveTextureUnit).BindingCubeMapArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.TextureBufferOffsetAlignment, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_ACTIVE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0.Active), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundTransformFeedback), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0.Buffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.TransformFeedbackBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0.Buffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0.Buffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_TRANSFORM_FEEDBACK_PAUSED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0.Paused), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.UniformBuffers.Get(index).Binding), ϟa, ϟs, ϟd, ϟb)
} else {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.UniformBuffer), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.Constants.UniformBufferOffsetAlignment, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNIFORM_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.UniformBuffers.Get(index).Size), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNIFORM_BUFFER_START:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if isIndexed {
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundBuffers.UniformBuffers.Get(index).Start), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_UNPACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackAlignment, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackImageHeight, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackRowLength, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackSkipImages, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackSkipPixels, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_UNPACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ctx.PixelStorage.UnpackSkipRows, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_ARRAY_BINDING:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.BoundVertexArray), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_VERTEX_BINDING_DIVISOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Divisor), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_OFFSET:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Offset), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VERTEX_BINDING_STRIDE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if isIndexed {
i := VertexBufferBindingIndex(index)
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).VertexBufferBindings.Get(i).Stride), ϟa, ϟs, ϟd, ϟb)
} else {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
case GLenum_GL_VIEWPORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := v.Slice(uint64(0), uint64(4), ϟs)
s.Index(uint64(0), ϟs).Write(ϟctx, ctx.Rasterization.Viewport.X, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(1), ϟs).Write(ϟctx, ctx.Rasterization.Viewport.Y, ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(2), ϟs).Write(ϟctx, GLint(ctx.Rasterization.Viewport.Width), ϟa, ϟs, ϟd, ϟb)
s.Index(uint64(3), ϟs).Write(ϟctx, GLint(ctx.Rasterization.Viewport.Height), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.Constants.MaxTextureMaxAnisotropyExt), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_GPU_DISJOINT_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
v.Slice(uint64(0), uint64(1), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, name); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetSamplerParameterv_GLfloat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLfloatᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAG_FILTER:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, s.MinLod, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, s.MaxLod, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(s.WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, s.BorderColor.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, s.BorderColor.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, s.BorderColor.Elements[uint64(2)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, s.BorderColor.Elements[uint64(3)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, s.MaxAnisotropy, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subGetTexParameter_GLfloat(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, parameter GLenum, params GLfloatᵖ) error {
switch target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP:
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch parameter {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).MagFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).MinFilter), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).WrapS), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).WrapT), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).BaseLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_FUNC:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).CompareFunc), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_COMPARE_MODE:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).CompareMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_FORMAT:
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).ImmutableFormat), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).MaxLevel), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).MaxLod, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).MinLod, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).SwizzleA), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).SwizzleB), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).SwizzleG), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).SwizzleR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).WrapR), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).DepthStencilTextureMode), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_IMMUTABLE_LEVELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(t.OnAccess(ϟs).ImmutableLevels), ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
p := params.Slice(uint64(0), uint64(4), ϟs)
p.Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).BorderColor.Elements[uint64(0)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(1), ϟs).Write(ϟctx, t.OnAccess(ϟs).BorderColor.Elements[uint64(1)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(2), ϟs).Write(ϟctx, t.OnAccess(ϟs).BorderColor.Elements[uint64(2)], ϟa, ϟs, ϟd, ϟb)
p.Index(uint64(3), ϟs).Write(ϟctx, t.OnAccess(ϟs).BorderColor.Elements[uint64(3)], ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, t.OnAccess(ϟs).MaxAnisotropy, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSamplerParameterv_Vec1f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params Vec1f) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
s.CompareFunc = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_COMPARE_MODE:
s.CompareMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MIN_FILTER:
s.MinFilter = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MAG_FILTER:
s.MagFilter = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MIN_LOD:
s.MinLod = params.Elements[uint64(0)]
case GLenum_GL_TEXTURE_MAX_LOD:
s.MaxLod = params.Elements[uint64(0)]
case GLenum_GL_TEXTURE_WRAP_R:
s.WrapR = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_WRAP_S:
s.WrapS = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_WRAP_T:
s.WrapT = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
s.MaxAnisotropy = params.Elements[uint64(0)]
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSamplerParameterv_GLfloat__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params GLfloatᶜᵖ) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
s.CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
s.CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_FILTER:
s.MinFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAG_FILTER:
s.MagFilter = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MIN_LOD:
s.MinLod = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MAX_LOD:
s.MaxLod = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_WRAP_R:
s.WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_S:
s.WrapS = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_WRAP_T:
s.WrapT = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
s.MaxAnisotropy = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subSamplerParameterv_Vec1i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, sampler SamplerId, pname GLenum, params Vec1i) error {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Samplers.Get(sampler)
switch pname {
case GLenum_GL_TEXTURE_COMPARE_FUNC:
s.CompareFunc = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_COMPARE_MODE:
s.CompareMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MIN_FILTER:
s.MinFilter = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MAG_FILTER:
s.MagFilter = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MIN_LOD:
s.MinLod = GLfloat(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MAX_LOD:
s.MaxLod = GLfloat(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_WRAP_R:
s.WrapR = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_WRAP_S:
s.WrapS = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_WRAP_T:
s.WrapT = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
s.MaxAnisotropy = GLfloat(params.Elements[uint64(0)])
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexParameterv_Vec1f(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params Vec1f) error {
if (target) == (GLenum_GL_TEXTURE_BUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch pname {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
magFilter := GLenum(params.Elements[uint64(0)])
switch magFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, magFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MagFilter = magFilter
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
minFilter := GLenum(params.Elements[uint64(0)])
switch minFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR, GLenum_GL_NEAREST_MIPMAP_NEAREST, GLenum_GL_LINEAR_MIPMAP_NEAREST, GLenum_GL_NEAREST_MIPMAP_LINEAR, GLenum_GL_LINEAR_MIPMAP_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, minFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MinFilter = minFilter
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapS = _res_0
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapT = _res_0
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
baseLevel := GLint(params.Elements[uint64(0)])
if (baseLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).BaseLevel = baseLevel
case GLenum_GL_TEXTURE_COMPARE_FUNC:
t.OnAccess(ϟs).CompareFunc = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_COMPARE_MODE:
t.OnAccess(ϟs).CompareMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
maxLevel := GLint(params.Elements[uint64(0)])
if (maxLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MaxLevel = maxLevel
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxLod = params.Elements[uint64(0)]
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MinLod = params.Elements[uint64(0)]
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleA = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleB = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleG = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleR = _res_0
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapR = GLenum(params.Elements[uint64(0)])
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).DepthStencilTextureMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxAnisotropy = params.Elements[uint64(0)]
case GLenum_GL_TEXTURE_SRGB_DECODE_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_sRGB_decode); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexParameterv_GLfloat__CP(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params GLfloatᶜᵖ) error {
if (target) == (GLenum_GL_TEXTURE_BUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch pname {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
magFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch magFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, magFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MagFilter = magFilter
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
minFilter := GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
switch minFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR, GLenum_GL_NEAREST_MIPMAP_NEAREST, GLenum_GL_LINEAR_MIPMAP_NEAREST, GLenum_GL_NEAREST_MIPMAP_LINEAR, GLenum_GL_LINEAR_MIPMAP_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, minFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MinFilter = minFilter
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapS = _res_0
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapT = _res_0
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
baseLevel := GLint(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
if (baseLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).BaseLevel = baseLevel
case GLenum_GL_TEXTURE_COMPARE_FUNC:
t.OnAccess(ϟs).CompareFunc = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_COMPARE_MODE:
t.OnAccess(ϟs).CompareMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
maxLevel := GLint(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
if (maxLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MaxLevel = maxLevel
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxLod = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MinLod = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleA = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleB = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleG = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleR = _res_0
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapR = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).DepthStencilTextureMode = GLenum(params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxAnisotropy = params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_TEXTURE_SRGB_DECODE_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_sRGB_decode); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
func subTexParameterv_Vec1i(ϟctx log.Context, ϟa atom.Atom, ϟo *atom.Observations, ϟs *gfxapi.State, ϟc *State, ϟd database.Database, ϟb *builder.Builder, target GLenum, pname GLenum, params Vec1i) error {
if (target) == (GLenum_GL_TEXTURE_BUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, target)
if ϟerr != nil {
return ϟerr
}
switch pname {
case GLenum_GL_TEXTURE_MAG_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
magFilter := GLenum(params.Elements[uint64(0)])
switch magFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, magFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MagFilter = magFilter
case GLenum_GL_TEXTURE_MIN_FILTER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
minFilter := GLenum(params.Elements[uint64(0)])
switch minFilter {
case GLenum_GL_NEAREST, GLenum_GL_LINEAR, GLenum_GL_NEAREST_MIPMAP_NEAREST, GLenum_GL_LINEAR_MIPMAP_NEAREST, GLenum_GL_NEAREST_MIPMAP_LINEAR, GLenum_GL_LINEAR_MIPMAP_LINEAR:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, minFilter); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MinFilter = minFilter
case GLenum_GL_TEXTURE_WRAP_S:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapS = _res_0
case GLenum_GL_TEXTURE_WRAP_T:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckWrapParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapT = _res_0
case GLenum_GL_TEXTURE_BASE_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
baseLevel := params.Elements[uint64(0)]
if (baseLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).BaseLevel = baseLevel
case GLenum_GL_TEXTURE_COMPARE_FUNC:
t.OnAccess(ϟs).CompareFunc = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_COMPARE_MODE:
t.OnAccess(ϟs).CompareMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MAX_LEVEL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
maxLevel := params.Elements[uint64(0)]
if (maxLevel) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t.OnAccess(ϟs).MaxLevel = maxLevel
case GLenum_GL_TEXTURE_MAX_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxLod = GLfloat(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_MIN_LOD:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MinLod = GLfloat(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_SWIZZLE_A:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleA = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_B:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleB = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_G:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleG = _res_0
case GLenum_GL_TEXTURE_SWIZZLE_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subCheckSwizzleParam(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(params.Elements[uint64(0)]))
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).SwizzleR = _res_0
case GLenum_GL_TEXTURE_WRAP_R:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).WrapR = GLenum(params.Elements[uint64(0)])
case GLenum_GL_DEPTH_STENCIL_TEXTURE_MODE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).DepthStencilTextureMode = GLenum(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_BORDER_COLOR:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_filter_anisotropic); ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).MaxAnisotropy = GLfloat(params.Elements[uint64(0)])
case GLenum_GL_TEXTURE_SRGB_DECODE_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_sRGB_decode); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, pname); ϟerr != nil {
return ϟerr
}
}
return nil
}
var _ = atom.Atom(&GlBlendBarrierKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendBarrierKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendBarrierKHR().
func (ϟa *GlBlendBarrierKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_blend_equation_advanced); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendBarrier(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendBarrierKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendBarrierKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlBlendBarrierKHR)
}
var _ = atom.Atom(&GlBlendEquationSeparateiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationSeparateiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationSeparateiEXT().
func (ϟa *GlBlendEquationSeparateiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.ModeRGB, ϟa.ModeAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationSeparateiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationSeparateiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.ModeRGB))
ϟb.Push(value.U32(ϟa.ModeAlpha))
ϟb.Call(funcInfoGlBlendEquationSeparateiEXT)
}
var _ = atom.Atom(&GlBlendEquationiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationiEXT().
func (ϟa *GlBlendEquationiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Mode); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlBlendEquationiEXT)
}
var _ = atom.Atom(&GlBlendFuncSeparateiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFuncSeparateiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFuncSeparateiEXT().
func (ϟa *GlBlendFuncSeparateiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFuncSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.SrcRGB, ϟa.DstRGB, ϟa.SrcAlpha, ϟa.DstAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFuncSeparateiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFuncSeparateiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcRGB))
ϟb.Push(value.U32(ϟa.DstRGB))
ϟb.Push(value.U32(ϟa.SrcAlpha))
ϟb.Push(value.U32(ϟa.DstAlpha))
ϟb.Call(funcInfoGlBlendFuncSeparateiEXT)
}
var _ = atom.Atom(&GlBlendFunciEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFunciEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFunciEXT().
func (ϟa *GlBlendFunciEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFunci(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Src, ϟa.Dst); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFunciEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFunciEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Src))
ϟb.Push(value.U32(ϟa.Dst))
ϟb.Call(funcInfoGlBlendFunciEXT)
}
var _ = atom.Atom(&GlColorMaskiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorMaskiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorMaskiEXT().
func (ϟa *GlColorMaskiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subColorMaski(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.R, ϟa.G, ϟa.B, ϟa.A); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorMaskiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorMaskiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.G.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.A.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorMaskiEXT)
}
var _ = atom.Atom(&GlCopyImageSubDataEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyImageSubDataEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyImageSubDataEXT().
func (ϟa *GlCopyImageSubDataEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_copy_image); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyImageSubData(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.SrcName, ϟa.SrcTarget, ϟa.SrcLevel, ϟa.SrcX, ϟa.SrcY, ϟa.SrcZ, ϟa.DstName, ϟa.DstTarget, ϟa.DstLevel, ϟa.DstX, ϟa.DstY, ϟa.DstZ, ϟa.SrcWidth, ϟa.SrcHeight, ϟa.SrcDepth); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyImageSubDataEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyImageSubDataEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcTarget))
ϟb.Push(ϟa.SrcLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.DstTarget))
ϟb.Push(ϟa.DstLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcWidth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcHeight.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcDepth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyImageSubDataEXT)
}
var _ = atom.Atom(&GlDebugMessageCallbackKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageCallbackKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageCallbackKHR().
func (ϟa *GlDebugMessageCallbackKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageCallback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Callback, ϟa.UserParam); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageCallbackKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageCallbackKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Callback.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.UserParam.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageCallbackKHR)
}
var _ = atom.Atom(&GlDebugMessageControlKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageControlKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageControlKHR().
func (ϟa *GlDebugMessageControlKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageControl(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Type, ϟa.Severity, ϟa.Count, ϟa.Ids, ϟa.Enabled); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageControlKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageControlKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(value.U32(ϟa.Severity))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Enabled.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageControlKHR)
}
var _ = atom.Atom(&GlDebugMessageInsertKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageInsertKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageInsertKHR().
func (ϟa *GlDebugMessageInsertKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageInsert(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Type, ϟa.Id, ϟa.Severity, ϟa.Length, ϟa.Message); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageInsertKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageInsertKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Severity))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Message.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageInsertKHR)
}
var _ = atom.Atom(&GlDisableiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableiEXT().
func (ϟa *GlDisableiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subDisablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableiEXT)
}
var _ = atom.Atom(&GlEnableiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableiEXT().
func (ϟa *GlEnableiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subEnablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableiEXT)
}
var _ = atom.Atom(&GlFramebufferTextureEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureEXT().
func (ϟa *GlFramebufferTextureEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_geometry_shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureEXT)
}
var _ = atom.Atom(&GlGetDebugMessageLogKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetDebugMessageLogKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetDebugMessageLogKHR().
// Upon returning the glGetDebugMessageLogKHR() return value will be stored on the stack.
func (ϟa *GlGetDebugMessageLogKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
l := ϟa.Result
if ϟerr := subGetDebugMessageLog(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.BufSize, ϟa.Sources, ϟa.Types, ϟa.Ids, ϟa.Severities, ϟa.Lengths, ϟa.MessageLog, l); ϟerr != nil {
return ϟerr
}
_ = l
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetDebugMessageLogKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetDebugMessageLogKHR() return value will be stored on the stack.
func (ϟa *GlGetDebugMessageLogKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Sources.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Types.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Severities.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Lengths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MessageLog.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetDebugMessageLogKHR)
}
var _ = atom.Atom(&GlGetObjectLabelKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetObjectLabelKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetObjectLabelKHR().
func (ϟa *GlGetObjectLabelKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetObjectLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Identifier, ϟa.Name, ϟa.BufSize, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetObjectLabelKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetObjectLabelKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Identifier))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetObjectLabelKHR)
}
var _ = atom.Atom(&GlGetObjectPtrLabelKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetObjectPtrLabelKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetObjectPtrLabelKHR().
func (ϟa *GlGetObjectPtrLabelKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetObjectPtrLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Ptr, ϟa.BufSize, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetObjectPtrLabelKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetObjectPtrLabelKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Ptr.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetObjectPtrLabelKHR)
}
var _ = atom.Atom(&GlGetPointervKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPointervKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPointervKHR().
func (ϟa *GlGetPointervKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetPointerv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPointervKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPointervKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPointervKHR)
}
var _ = atom.Atom(&GlGetSamplerParameterIivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIivEXT().
func (ϟa *GlGetSamplerParameterIivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIivEXT)
}
var _ = atom.Atom(&GlGetSamplerParameterIuivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIuivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIuivEXT().
func (ϟa *GlGetSamplerParameterIuivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIuivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIuivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIuivEXT)
}
var _ = atom.Atom(&GlGetTexParameterIivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIivEXT().
func (ϟa *GlGetTexParameterIivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIivEXT)
}
var _ = atom.Atom(&GlGetTexParameterIuivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIuivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIuivEXT().
func (ϟa *GlGetTexParameterIuivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIuivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIuivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIuivEXT)
}
var _ = atom.Atom(&GlIsEnablediEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsEnablediEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsEnablediEXT().
// Upon returning the glIsEnablediEXT() return value will be stored on the stack.
func (ϟa *GlIsEnablediEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsEnabledi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsEnablediEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsEnablediEXT() return value will be stored on the stack.
func (ϟa *GlIsEnablediEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsEnablediEXT)
}
var _ = atom.Atom(&GlMinSampleShadingOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMinSampleShadingOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMinSampleShadingOES().
func (ϟa *GlMinSampleShadingOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_sample_shading); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinSampleShading(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMinSampleShadingOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMinSampleShadingOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMinSampleShadingOES)
}
var _ = atom.Atom(&GlObjectLabelKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glObjectLabelKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glObjectLabelKHR().
func (ϟa *GlObjectLabelKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subObjectLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Identifier, ϟa.Name, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glObjectLabelKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlObjectLabelKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Identifier))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlObjectLabelKHR)
}
var _ = atom.Atom(&GlObjectPtrLabelKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glObjectPtrLabelKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glObjectPtrLabelKHR().
func (ϟa *GlObjectPtrLabelKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subObjectPtrLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Ptr, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glObjectPtrLabelKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlObjectPtrLabelKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Ptr.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlObjectPtrLabelKHR)
}
var _ = atom.Atom(&GlPatchParameteriEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPatchParameteriEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPatchParameteriEXT().
func (ϟa *GlPatchParameteriEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_tessellation_shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subPatchParameteri(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPatchParameteriEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPatchParameteriEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPatchParameteriEXT)
}
var _ = atom.Atom(&GlPopDebugGroupKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPopDebugGroupKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPopDebugGroupKHR().
func (ϟa *GlPopDebugGroupKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subPopDebugGroup(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPopDebugGroupKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPopDebugGroupKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPopDebugGroupKHR)
}
var _ = atom.Atom(&GlPrimitiveBoundingBoxEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPrimitiveBoundingBoxEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPrimitiveBoundingBoxEXT().
func (ϟa *GlPrimitiveBoundingBoxEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_primitive_bounding_box); ϟerr != nil {
return ϟerr
}
if ϟerr := subPrimitiveBoundingBox(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.MinX, ϟa.MinY, ϟa.MinZ, ϟa.MinW, ϟa.MaxX, ϟa.MaxY, ϟa.MaxZ, ϟa.MaxW); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPrimitiveBoundingBoxEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPrimitiveBoundingBoxEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.MinX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinW.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxW.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPrimitiveBoundingBoxEXT)
}
var _ = atom.Atom(&GlPushDebugGroupKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPushDebugGroupKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPushDebugGroupKHR().
func (ϟa *GlPushDebugGroupKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_debug); ϟerr != nil {
return ϟerr
}
if ϟerr := subPushDebugGroup(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Id, ϟa.Length, ϟa.Message); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPushDebugGroupKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPushDebugGroupKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Message.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPushDebugGroupKHR)
}
var _ = atom.Atom(&GlSamplerParameterIivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIivEXT().
func (ϟa *GlSamplerParameterIivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIivEXT)
}
var _ = atom.Atom(&GlSamplerParameterIuivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIuivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIuivEXT().
func (ϟa *GlSamplerParameterIuivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIuivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIuivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIuivEXT)
}
var _ = atom.Atom(&GlTexBufferEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBufferEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBufferEXT().
func (ϟa *GlTexBufferEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBufferEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBufferEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlTexBufferEXT)
}
var _ = atom.Atom(&GlTexBufferRangeEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBufferRangeEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBufferRangeEXT().
func (ϟa *GlTexBufferRangeEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer, ϟa.Offset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBufferRangeEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBufferRangeEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexBufferRangeEXT)
}
var _ = atom.Atom(&GlTexParameterIivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIivEXT().
func (ϟa *GlTexParameterIivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIivEXT)
}
var _ = atom.Atom(&GlTexParameterIuivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIuivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIuivEXT().
func (ϟa *GlTexParameterIuivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIuivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIuivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIuivEXT)
}
var _ = atom.Atom(&GlTexStorage3DMultisampleOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage3DMultisampleOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage3DMultisampleOES().
func (ϟa *GlTexStorage3DMultisampleOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_storage_multisample_2d_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage3DMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Samples, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Fixedsamplelocations); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage3DMultisampleOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage3DMultisampleOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fixedsamplelocations.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage3DMultisampleOES)
}
var _ = atom.Atom(&GlBeginQuery{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginQuery.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginQuery().
func (ϟa *GlBeginQuery) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_ANY_SAMPLES_PASSED, GLenum_GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GLenum_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
case GLenum_GL_PRIMITIVES_GENERATED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.ActiveQueries[ϟa.Target] = ϟa.Query
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginQuery().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginQuery) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBeginQuery)
}
var _ = atom.Atom(&GlDeleteQueries{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteQueries.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteQueries().
func (ϟa *GlDeleteQueries) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
q := ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := q.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (QueryId(uint32(0))) {
delete(ctx.Instances.Queries, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteQueries().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteQueries) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Queries.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteQueries)
}
var _ = atom.Atom(&GlEndQuery{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndQuery.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndQuery().
func (ϟa *GlEndQuery) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_ANY_SAMPLES_PASSED, GLenum_GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GLenum_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
case GLenum_GL_PRIMITIVES_GENERATED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
delete(ctx.ActiveQueries, ϟa.Target)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndQuery().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndQuery) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlEndQuery)
}
var _ = atom.Atom(&GlGenQueries{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenQueries.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenQueries().
func (ϟa *GlGenQueries) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
q := ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := QueryId(ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Queries[id] = &Query{}
q.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenQueries().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenQueries) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Queries.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenQueries)
}
var _ = atom.Atom(&GlGetQueryObjectuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjectuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjectuiv().
func (ϟa *GlGetQueryObjectuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Parameter {
case GLenum_GL_QUERY_RESULT, GLenum_GL_QUERY_RESULT_AVAILABLE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjectuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjectuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjectuiv)
}
var _ = atom.Atom(&GlGetQueryiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryiv().
func (ϟa *GlGetQueryiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_ANY_SAMPLES_PASSED, GLenum_GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GLenum_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
case GLenum_GL_PRIMITIVES_GENERATED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TIMESTAMP_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
switch ϟa.Parameter {
case GLenum_GL_CURRENT_QUERY:
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ctx.ActiveQueries.Contains(ϟa.Target) {
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ctx.ActiveQueries.Get(ϟa.Target)), ϟa, ϟs, ϟd, ϟb)
} else {
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(int32(0)), ϟa, ϟs, ϟd, ϟb)
}
case GLenum_GL_QUERY_COUNTER_BITS_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryiv)
}
var _ = atom.Atom(&GlIsQuery{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsQuery.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsQuery().
// Upon returning the glIsQuery() return value will be stored on the stack.
func (ϟa *GlIsQuery) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Queries.Contains(ϟa.Query) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsQuery().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsQuery() return value will be stored on the stack.
func (ϟa *GlIsQuery) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsQuery)
}
var _ = atom.Atom(&GlBindBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindBuffer().
func (ϟa *GlBindBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_ARRAY_BUFFER:
ctx.BoundBuffers.ArrayBuffer = ϟa.Buffer
case GLenum_GL_ELEMENT_ARRAY_BUFFER:
ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray).ElementArrayBuffer = ϟa.Buffer
case GLenum_GL_COPY_READ_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.CopyReadBuffer = ϟa.Buffer
case GLenum_GL_COPY_WRITE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.CopyWriteBuffer = ϟa.Buffer
case GLenum_GL_PIXEL_PACK_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.PixelPackBuffer = ϟa.Buffer
case GLenum_GL_PIXEL_UNPACK_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.PixelUnpackBuffer = ϟa.Buffer
case GLenum_GL_TRANSFORM_FEEDBACK_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.TransformFeedbackBuffer = ϟa.Buffer
case GLenum_GL_UNIFORM_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.UniformBuffer = ϟa.Buffer
case GLenum_GL_ATOMIC_COUNTER_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.AtomicCounterBuffer = ϟa.Buffer
case GLenum_GL_DISPATCH_INDIRECT_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.DispatchIndirectBuffer = ϟa.Buffer
case GLenum_GL_DRAW_INDIRECT_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.DrawIndirectBuffer = ϟa.Buffer
case GLenum_GL_SHADER_STORAGE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.ShaderStorageBuffer = ϟa.Buffer
case GLenum_GL_TEXTURE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
ctx.BoundBuffers.TextureBuffer = ϟa.Buffer
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if !(ctx.Instances.Buffers.Contains(ϟa.Buffer)) {
ctx.Instances.Buffers[ϟa.Buffer] = &Buffer{Size: GLsizeiptr(int32(0)), Usage: GLenum_GL_STATIC_DRAW, Mapped: GLboolean_GL_FALSE, MapPointer: U8ᵖ{}, MapOffset: GLintptr(int32(0)), MapLength: GLsizeiptr(int32(0))}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindBuffer)
}
var _ = atom.Atom(&GlBindBufferBase{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindBufferBase.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindBufferBase().
func (ϟa *GlBindBufferBase) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
size := func() (result GLsizeiptr) {
switch ctx.Instances.Buffers.Contains(ϟa.Buffer) {
case true:
return ctx.Instances.Buffers.Get(ϟa.Buffer).Size
case false:
return GLsizeiptr(int32(0))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ctx.Instances.Buffers.Contains(ϟa.Buffer), ϟa))
return result
}
}()
if ϟerr := subBindBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index, ϟa.Buffer, GLintptr(int32(0)), size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindBufferBase().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindBufferBase) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindBufferBase)
}
var _ = atom.Atom(&GlBindBufferRange{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindBufferRange.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindBufferRange().
func (ϟa *GlBindBufferRange) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBindBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index, ϟa.Buffer, ϟa.Offset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindBufferRange().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindBufferRange) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindBufferRange)
}
var _ = atom.Atom(&GlBufferData{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBufferData.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBufferData().
func (ϟa *GlBufferData) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Usage {
case GLenum_GL_DYNAMIC_DRAW, GLenum_GL_STATIC_DRAW, GLenum_GL_STREAM_DRAW:
case GLenum_GL_DYNAMIC_COPY, GLenum_GL_DYNAMIC_READ, GLenum_GL_STATIC_COPY, GLenum_GL_STATIC_READ, GLenum_GL_STREAM_COPY, GLenum_GL_STREAM_READ:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Usage); ϟerr != nil {
return ϟerr
}
}
if (ϟa.Size) < (GLsizeiptr(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
b.Data = func() (result U8ˢ) {
switch (ϟa.Data) != (BufferDataPointer(Voidᶜᵖ{})) {
case true:
return U8ᵖ(ϟa.Data).Slice(uint64(GLsizeiptr(int32(0))), uint64(ϟa.Size), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
case false:
return MakeU8ˢ(uint64(ϟa.Size), ϟs)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (ϟa.Data) != (BufferDataPointer(Voidᶜᵖ{})), ϟa))
return result
}
}()
b.Size = ϟa.Size
b.Usage = ϟa.Usage
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBufferData().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBufferData) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Usage))
ϟb.Call(funcInfoGlBufferData)
}
var _ = atom.Atom(&GlBufferSubData{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBufferSubData.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBufferSubData().
func (ϟa *GlBufferSubData) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
b, ϟerr := subGetBoundBufferOrError(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
if ((ϟa.Offset) < (GLintptr(int32(0)))) || ((ϟa.Size) < (GLsizeiptr(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ((GLsizeiptr(ϟa.Offset)) + (ϟa.Size)) > (b.Size) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
b.Data.Slice(uint64(ϟa.Offset), uint64((GLsizeiptr(ϟa.Offset))+(ϟa.Size)), ϟs).Copy(ϟctx, U8ᵖ(ϟa.Data).Slice(uint64(GLsizeiptr(int32(0))), uint64(ϟa.Size), ϟs), ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBufferSubData().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBufferSubData) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBufferSubData)
}
var _ = atom.Atom(&GlCopyBufferSubData{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyBufferSubData.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyBufferSubData().
func (ϟa *GlCopyBufferSubData) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyBufferSubData(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ReadTarget, ϟa.WriteTarget, ϟa.ReadOffset, ϟa.WriteOffset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyBufferSubData().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyBufferSubData) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.ReadTarget))
ϟb.Push(value.U32(ϟa.WriteTarget))
ϟb.Push(ϟa.ReadOffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.WriteOffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyBufferSubData)
}
var _ = atom.Atom(&GlDeleteBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteBuffers().
func (ϟa *GlDeleteBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
b := ϟa.Buffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := b.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (BufferId(uint32(0))) {
delete(ctx.Instances.Buffers, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteBuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteBuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Buffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteBuffers)
}
var _ = atom.Atom(&GlGenBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenBuffers().
func (ϟa *GlGenBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
b := ϟa.Buffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := BufferId(ϟa.Buffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Buffers[id] = &Buffer{Size: GLsizeiptr(int32(0)), Usage: GLenum_GL_STATIC_DRAW, Mapped: GLboolean_GL_FALSE, MapPointer: U8ᵖ{}, MapOffset: GLintptr(int32(0)), MapLength: GLsizeiptr(int32(0))}
b.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenBuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenBuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Buffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenBuffers)
}
var _ = atom.Atom(&GlGetBufferParameteri64v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBufferParameteri64v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBufferParameteri64v().
func (ϟa *GlGetBufferParameteri64v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetBufferParameter_GLint64(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, ϟa.Value); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBufferParameteri64v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBufferParameteri64v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBufferParameteri64v)
}
var _ = atom.Atom(&GlGetBufferParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBufferParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBufferParameteriv().
func (ϟa *GlGetBufferParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetBufferParameter_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, ϟa.Value); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBufferParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBufferParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBufferParameteriv)
}
var _ = atom.Atom(&GlGetBufferPointerv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBufferPointerv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBufferPointerv().
func (ϟa *GlGetBufferPointerv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetBufferPointerv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBufferPointerv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBufferPointerv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBufferPointerv)
}
var _ = atom.Atom(&GlIsBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsBuffer().
// Upon returning the glIsBuffer() return value will be stored on the stack.
func (ϟa *GlIsBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Buffers.Contains(ϟa.Buffer) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsBuffer() return value will be stored on the stack.
func (ϟa *GlIsBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsBuffer)
}
var _ = atom.Atom(&GlMapBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMapBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMapBuffer().
// Upon returning the glMapBuffer() return value will be stored on the stack.
func (ϟa *GlMapBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ptr := ϟa.Result
if ϟerr := subMapBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Access, U8ᵖ(ptr)); ϟerr != nil {
return ϟerr
}
_ = ptr
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMapBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glMapBuffer() return value will be stored on the stack.
func (ϟa *GlMapBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Call(funcInfoGlMapBuffer)
}
var _ = atom.Atom(&GlMapBufferRange{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMapBufferRange.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMapBufferRange().
// Upon returning the glMapBufferRange() return value will be stored on the stack.
func (ϟa *GlMapBufferRange) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ptr := ϟa.Result
if ϟerr := subMapBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Offset, ϟa.Length, ϟa.Access, U8ᵖ(ptr)); ϟerr != nil {
return ϟerr
}
_ = ptr
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMapBufferRange().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glMapBufferRange() return value will be stored on the stack.
func (ϟa *GlMapBufferRange) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Call(funcInfoGlMapBufferRange)
}
var _ = atom.Atom(&GlUnmapBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUnmapBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUnmapBuffer().
// Upon returning the glUnmapBuffer() return value will be stored on the stack.
func (ϟa *GlUnmapBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUnmapBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUnmapBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glUnmapBuffer() return value will be stored on the stack.
func (ϟa *GlUnmapBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlUnmapBuffer)
}
var _ = atom.Atom(&GlFlushMappedBufferRange{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFlushMappedBufferRange.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFlushMappedBufferRange().
func (ϟa *GlFlushMappedBufferRange) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subFlushMappedBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Offset, ϟa.Length); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFlushMappedBufferRange().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFlushMappedBufferRange) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFlushMappedBufferRange)
}
var _ = atom.Atom(&GlDebugMessageCallback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageCallback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageCallback().
func (ϟa *GlDebugMessageCallback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageCallback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Callback, ϟa.UserParam); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageCallback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageCallback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Callback.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.UserParam.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageCallback)
}
var _ = atom.Atom(&GlDebugMessageControl{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageControl.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageControl().
func (ϟa *GlDebugMessageControl) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageControl(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Type, ϟa.Severity, ϟa.Count, ϟa.Ids, ϟa.Enabled); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageControl().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageControl) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(value.U32(ϟa.Severity))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Enabled.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageControl)
}
var _ = atom.Atom(&GlDebugMessageInsert{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDebugMessageInsert.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDebugMessageInsert().
func (ϟa *GlDebugMessageInsert) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDebugMessageInsert(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Type, ϟa.Id, ϟa.Severity, ϟa.Length, ϟa.Message); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDebugMessageInsert().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDebugMessageInsert) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Severity))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Message.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDebugMessageInsert)
}
var _ = atom.Atom(&GlGetDebugMessageLog{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetDebugMessageLog.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetDebugMessageLog().
// Upon returning the glGetDebugMessageLog() return value will be stored on the stack.
func (ϟa *GlGetDebugMessageLog) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
l := ϟa.Result
if ϟerr := subGetDebugMessageLog(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.BufSize, ϟa.Sources, ϟa.Types, ϟa.Ids, ϟa.Severities, ϟa.Lengths, ϟa.MessageLog, l); ϟerr != nil {
return ϟerr
}
_ = l
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetDebugMessageLog().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetDebugMessageLog() return value will be stored on the stack.
func (ϟa *GlGetDebugMessageLog) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Sources.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Types.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Severities.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Lengths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MessageLog.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetDebugMessageLog)
}
var _ = atom.Atom(&GlGetObjectLabel{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetObjectLabel.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetObjectLabel().
func (ϟa *GlGetObjectLabel) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetObjectLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Identifier, ϟa.Name, ϟa.BufSize, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetObjectLabel().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetObjectLabel) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Identifier))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetObjectLabel)
}
var _ = atom.Atom(&GlGetObjectPtrLabel{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetObjectPtrLabel.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetObjectPtrLabel().
func (ϟa *GlGetObjectPtrLabel) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetObjectPtrLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Ptr, ϟa.BufSize, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetObjectPtrLabel().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetObjectPtrLabel) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Ptr.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetObjectPtrLabel)
}
var _ = atom.Atom(&GlGetPointerv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPointerv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPointerv().
func (ϟa *GlGetPointerv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetPointerv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPointerv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPointerv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPointerv)
}
var _ = atom.Atom(&GlObjectLabel{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glObjectLabel.
// If ϟb is not nil, Mutate also emits the replay instructions to call glObjectLabel().
func (ϟa *GlObjectLabel) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subObjectLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Identifier, ϟa.Name, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glObjectLabel().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlObjectLabel) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Identifier))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlObjectLabel)
}
var _ = atom.Atom(&GlObjectPtrLabel{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glObjectPtrLabel.
// If ϟb is not nil, Mutate also emits the replay instructions to call glObjectPtrLabel().
func (ϟa *GlObjectPtrLabel) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subObjectPtrLabel(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Ptr, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glObjectPtrLabel().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlObjectPtrLabel) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Ptr.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlObjectPtrLabel)
}
var _ = atom.Atom(&GlPopDebugGroup{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPopDebugGroup.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPopDebugGroup().
func (ϟa *GlPopDebugGroup) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subPopDebugGroup(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPopDebugGroup().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPopDebugGroup) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPopDebugGroup)
}
var _ = atom.Atom(&GlPushDebugGroup{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPushDebugGroup.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPushDebugGroup().
func (ϟa *GlPushDebugGroup) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subPushDebugGroup(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Source, ϟa.Id, ϟa.Length, ϟa.Message); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPushDebugGroup().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPushDebugGroup) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Source))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Message.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPushDebugGroup)
}
var _ = atom.Atom(&GlDrawArrays{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArrays.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArrays().
func (ϟa *GlDrawArrays) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckPrimitiveType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode); ϟerr != nil {
return ϟerr
}
if (ϟa.FirstIndex) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (ϟa.IndicesCount) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subReadVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, uint32(ϟa.FirstIndex), uint32(ϟa.IndicesCount), uint32(1)); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArrays().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArrays) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.FirstIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArrays)
}
var _ = atom.Atom(&GlDrawArraysIndirect{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysIndirect.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysIndirect().
func (ϟa *GlDrawArraysIndirect) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckPrimitiveType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (ctx.BoundBuffers.DrawIndirectBuffer) == (BufferId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysIndirect().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysIndirect) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.Indirect.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysIndirect)
}
var _ = atom.Atom(&GlDrawArraysInstanced{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysInstanced.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysInstanced().
func (ϟa *GlDrawArraysInstanced) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawArraysInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode, ϟa.FirstIndex, ϟa.IndicesCount, ϟa.InstanceCount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysInstanced().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysInstanced) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.FirstIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.InstanceCount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysInstanced)
}
var _ = atom.Atom(&GlDrawElements{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElements.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElements().
func (ϟa *GlDrawElements) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.DrawMode, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, GLsizei(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElements().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElements) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElements)
}
var _ = atom.Atom(&GlDrawElementsBaseVertex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsBaseVertex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsBaseVertex().
func (ϟa *GlDrawElementsBaseVertex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, ϟa.BaseVertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsBaseVertex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsBaseVertex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseVertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsBaseVertex)
}
var _ = atom.Atom(&GlDrawElementsIndirect{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsIndirect.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsIndirect().
func (ϟa *GlDrawElementsIndirect) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckPrimitiveType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckIndicesType(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.IndicesType); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (ctx.BoundBuffers.DrawIndirectBuffer) == (BufferId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsIndirect().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsIndirect) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indirect.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsIndirect)
}
var _ = atom.Atom(&GlDrawElementsInstanced{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstanced.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstanced().
func (ϟa *GlDrawElementsInstanced) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, ϟa.InstanceCount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstanced().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstanced) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.InstanceCount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstanced)
}
var _ = atom.Atom(&GlDrawElementsInstancedBaseVertex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedBaseVertex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedBaseVertex().
func (ϟa *GlDrawElementsInstancedBaseVertex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstancedBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, ϟa.InstanceCount, ϟa.BaseVertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedBaseVertex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedBaseVertex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.InstanceCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseVertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedBaseVertex)
}
var _ = atom.Atom(&GlDrawRangeElements{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawRangeElements.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawRangeElements().
func (ϟa *GlDrawRangeElements) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.End) < (ϟa.Start) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElements(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.DrawMode, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, GLsizei(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawRangeElements().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawRangeElements) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.End.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawRangeElements)
}
var _ = atom.Atom(&GlDrawRangeElementsBaseVertex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawRangeElementsBaseVertex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawRangeElementsBaseVertex().
func (ϟa *GlDrawRangeElementsBaseVertex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawRangeElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.DrawMode, ϟa.Start, ϟa.End, ϟa.IndicesCount, ϟa.IndicesType, ϟa.Indices, ϟa.BaseVertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawRangeElementsBaseVertex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawRangeElementsBaseVertex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.DrawMode))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.End.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.IndicesCount.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.IndicesType))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseVertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawRangeElementsBaseVertex)
}
var _ = atom.Atom(&GlPatchParameteri{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPatchParameteri.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPatchParameteri().
func (ϟa *GlPatchParameteri) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subPatchParameteri(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPatchParameteri().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPatchParameteri) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPatchParameteri)
}
var _ = atom.Atom(&GlPrimitiveBoundingBox{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPrimitiveBoundingBox.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPrimitiveBoundingBox().
func (ϟa *GlPrimitiveBoundingBox) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subPrimitiveBoundingBox(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.MinX, ϟa.MinY, ϟa.MinZ, ϟa.MinW, ϟa.MaxX, ϟa.MaxY, ϟa.MaxZ, ϟa.MaxW); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPrimitiveBoundingBox().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPrimitiveBoundingBox) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.MinX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinW.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxW.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPrimitiveBoundingBox)
}
var _ = atom.Atom(&EglGetConfigAttrib{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetConfigAttrib.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetConfigAttrib().
// Upon returning the eglGetConfigAttrib() return value will be stored on the stack.
func (ϟa *EglGetConfigAttrib) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglBindAPI{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglBindAPI.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglBindAPI().
// Upon returning the eglBindAPI() return value will be stored on the stack.
func (ϟa *EglBindAPI) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglBindTexImage{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglBindTexImage.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglBindTexImage().
// Upon returning the eglBindTexImage() return value will be stored on the stack.
func (ϟa *EglBindTexImage) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglChooseConfig{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglChooseConfig.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglChooseConfig().
// Upon returning the eglChooseConfig() return value will be stored on the stack.
func (ϟa *EglChooseConfig) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
num := ϟa.NumConfig.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)
ϟa.NumConfig.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, num, ϟa, ϟs, ϟd, ϟb)
if (ϟa.Configs) != (EGLConfigᵖ{}) {
ϟa.Configs.Slice(uint64(int32(0)), uint64(num), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglClientWaitSyncKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglClientWaitSyncKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglClientWaitSyncKHR().
// Upon returning the eglClientWaitSyncKHR() return value will be stored on the stack.
func (ϟa *EglClientWaitSyncKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCopyBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCopyBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCopyBuffers().
// Upon returning the eglCopyBuffers() return value will be stored on the stack.
func (ϟa *EglCopyBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreateContext{}) // interface compliance check
func (ϟa *EglCreateContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Result
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.EGLContexts[context] = _res_0
_ = context
return nil
}
var _ = atom.Atom(&EglCreatePbufferFromClientBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreatePbufferFromClientBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreatePbufferFromClientBuffer().
// Upon returning the eglCreatePbufferFromClientBuffer() return value will be stored on the stack.
func (ϟa *EglCreatePbufferFromClientBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreatePbufferSurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreatePbufferSurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreatePbufferSurface().
// Upon returning the eglCreatePbufferSurface() return value will be stored on the stack.
func (ϟa *EglCreatePbufferSurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreatePixmapSurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreatePixmapSurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreatePixmapSurface().
// Upon returning the eglCreatePixmapSurface() return value will be stored on the stack.
func (ϟa *EglCreatePixmapSurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreateSyncKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreateSyncKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreateSyncKHR().
// Upon returning the eglCreateSyncKHR() return value will be stored on the stack.
func (ϟa *EglCreateSyncKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreateWindowSurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreateWindowSurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreateWindowSurface().
// Upon returning the eglCreateWindowSurface() return value will be stored on the stack.
func (ϟa *EglCreateWindowSurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglDestroyContext{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglDestroyContext.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglDestroyContext().
// Upon returning the eglDestroyContext() return value will be stored on the stack.
func (ϟa *EglDestroyContext) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglDestroySurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglDestroySurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglDestroySurface().
// Upon returning the eglDestroySurface() return value will be stored on the stack.
func (ϟa *EglDestroySurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglDestroySyncKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglDestroySyncKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglDestroySyncKHR().
// Upon returning the eglDestroySyncKHR() return value will be stored on the stack.
func (ϟa *EglDestroySyncKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetConfigs{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetConfigs.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetConfigs().
// Upon returning the eglGetConfigs() return value will be stored on the stack.
func (ϟa *EglGetConfigs) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
num := ϟa.NumConfig.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)
ϟa.NumConfig.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, num, ϟa, ϟs, ϟd, ϟb)
if (ϟa.Configs) != (EGLConfigᵖ{}) {
ϟa.Configs.Slice(uint64(int32(0)), uint64(num), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetCurrentContext{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetCurrentContext.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetCurrentContext().
// Upon returning the eglGetCurrentContext() return value will be stored on the stack.
func (ϟa *EglGetCurrentContext) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetCurrentDisplay{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetCurrentDisplay.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetCurrentDisplay().
// Upon returning the eglGetCurrentDisplay() return value will be stored on the stack.
func (ϟa *EglGetCurrentDisplay) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetCurrentSurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetCurrentSurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetCurrentSurface().
// Upon returning the eglGetCurrentSurface() return value will be stored on the stack.
func (ϟa *EglGetCurrentSurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetDisplay{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetDisplay.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetDisplay().
// Upon returning the eglGetDisplay() return value will be stored on the stack.
func (ϟa *EglGetDisplay) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetError{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetError.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetError().
// Upon returning the eglGetError() return value will be stored on the stack.
func (ϟa *EglGetError) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglGetSyncAttribKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglGetSyncAttribKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglGetSyncAttribKHR().
// Upon returning the eglGetSyncAttribKHR() return value will be stored on the stack.
func (ϟa *EglGetSyncAttribKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglInitialize{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglInitialize.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglInitialize().
// Upon returning the eglInitialize() return value will be stored on the stack.
func (ϟa *EglInitialize) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Major) != (EGLintᵖ{}) {
ϟa.Major.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Major.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
}
if (ϟa.Major) != (EGLintᵖ{}) {
ϟa.Minor.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Minor.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
}
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglMakeCurrent{}) // interface compliance check
func (ϟa *EglMakeCurrent) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Context) == (EGLContext(Voidᵖ{})) {
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, (*Context)(nil)); ϟerr != nil {
return ϟerr
}
} else {
if ϟc.EGLContexts.Contains(ϟa.Context) {
ctx := ϟc.EGLContexts.Get(ϟa.Context)
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx); ϟerr != nil {
return ϟerr
}
if !(ctx.Info.Initialized) {
if ϟerr := subApplyStaticContextState(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetEGLStaticContextState(ϟa.Display, ϟa.Draw, ϟa.Context))); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subApplyDynamicContextState(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetEGLDynamicContextState(ϟa.Display, ϟa.Draw, ϟa.Context))); ϟerr != nil {
return ϟerr
}
} else {
staticState := (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetEGLStaticContextState(ϟa.Display, ϟa.Draw, ϟa.Context))
dynamicState := (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetEGLDynamicContextState(ϟa.Display, ϟa.Draw, ϟa.Context))
if ((dynamicState) != ((*DynamicContextState)(nil))) && ((staticState) != ((*StaticContextState)(nil))) {
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_WARNING, messages.WarnUnknownContext(uint64(ϟa.Context.Address))))
ctx, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.EGLContexts[ϟa.Context] = ctx
if ϟerr := subApplyStaticContextState(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, staticState); ϟerr != nil {
return ϟerr
}
if ϟerr := subApplyDynamicContextState(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, dynamicState); ϟerr != nil {
return ϟerr
}
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx); ϟerr != nil {
return ϟerr
}
} else {
if (ϟa.Context) != (EGLContext(Voidᵖ{})) {
_ = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.newMsg(Severity_SEVERITY_ERROR, messages.ErrContextDoesNotExist(uint64(ϟa.Context.Address))))
return atom.ErrAborted("eglMakeCurrent")
}
}
}
}
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglQueryAPI{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglQueryAPI.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglQueryAPI().
// Upon returning the eglQueryAPI() return value will be stored on the stack.
func (ϟa *EglQueryAPI) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglQueryContext{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglQueryContext.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglQueryContext().
// Upon returning the eglQueryContext() return value will be stored on the stack.
func (ϟa *EglQueryContext) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglQuerySurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglQuerySurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglQuerySurface().
// Upon returning the eglQuerySurface() return value will be stored on the stack.
func (ϟa *EglQuerySurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglQueryString{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglQueryString.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglQueryString().
// Upon returning the eglQueryString() return value will be stored on the stack.
func (ϟa *EglQueryString) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglReleaseTexImage{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglReleaseTexImage.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglReleaseTexImage().
// Upon returning the eglReleaseTexImage() return value will be stored on the stack.
func (ϟa *EglReleaseTexImage) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglReleaseThread{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglReleaseThread.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglReleaseThread().
// Upon returning the eglReleaseThread() return value will be stored on the stack.
func (ϟa *EglReleaseThread) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglSignalSyncKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglSignalSyncKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglSignalSyncKHR().
// Upon returning the eglSignalSyncKHR() return value will be stored on the stack.
func (ϟa *EglSignalSyncKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglSurfaceAttrib{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglSurfaceAttrib.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglSurfaceAttrib().
// Upon returning the eglSurfaceAttrib() return value will be stored on the stack.
func (ϟa *EglSurfaceAttrib) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglSwapBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglSwapBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglSwapBuffers().
// Upon returning the eglSwapBuffers() return value will be stored on the stack.
func (ϟa *EglSwapBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglSwapBuffersWithDamageKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglSwapBuffersWithDamageKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglSwapBuffersWithDamageKHR().
// Upon returning the eglSwapBuffersWithDamageKHR() return value will be stored on the stack.
func (ϟa *EglSwapBuffersWithDamageKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Rects.Slice(uint64(int32(0)), uint64((ϟa.NRects)*(EGLint(int32(4)))), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglSwapInterval{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglSwapInterval.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglSwapInterval().
// Upon returning the eglSwapInterval() return value will be stored on the stack.
func (ϟa *EglSwapInterval) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglTerminate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglTerminate.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglTerminate().
// Upon returning the eglTerminate() return value will be stored on the stack.
func (ϟa *EglTerminate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglWaitClient{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglWaitClient.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglWaitClient().
// Upon returning the eglWaitClient() return value will be stored on the stack.
func (ϟa *EglWaitClient) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglWaitGL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglWaitGL.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglWaitGL().
// Upon returning the eglWaitGL() return value will be stored on the stack.
func (ϟa *EglWaitGL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglWaitNative{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglWaitNative.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglWaitNative().
// Upon returning the eglWaitNative() return value will be stored on the stack.
func (ϟa *EglWaitNative) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreateImageKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreateImageKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreateImageKHR().
// Upon returning the eglCreateImageKHR() return value will be stored on the stack.
func (ϟa *EglCreateImageKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_EGL_KHR_image_base); ϟerr != nil {
return ϟerr
}
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
img := ϟa.Result
if (ϟa.Target) == (EGLenum_EGL_NATIVE_BUFFER_ANDROID) {
ϟc.EGLImages[img] = (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetAndroidNativeBufferExtra(Voidᵖ(ϟa.Buffer)))
}
_ = img
return nil
}
var _ = atom.Atom(&EglDestroyImageKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglDestroyImageKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglDestroyImageKHR().
// Upon returning the eglDestroyImageKHR() return value will be stored on the stack.
func (ϟa *EglDestroyImageKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_EGL_KHR_image_base); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&EglCreateNativeClientBufferANDROID{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for eglCreateNativeClientBufferANDROID.
// If ϟb is not nil, Mutate also emits the replay instructions to call eglCreateNativeClientBufferANDROID().
// Upon returning the eglCreateNativeClientBufferANDROID() return value will be stored on the stack.
func (ϟa *EglCreateNativeClientBufferANDROID) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_EGL_ANDROID_create_native_client_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subObserveAttribList(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.AttribList); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke eglCreateNativeClientBufferANDROID().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The eglCreateNativeClientBufferANDROID() return value will be stored on the stack.
func (ϟa *EglCreateNativeClientBufferANDROID) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.AttribList.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoEglCreateNativeClientBufferANDROID)
}
var _ = atom.Atom(&GlActiveShaderProgramEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glActiveShaderProgramEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glActiveShaderProgramEXT().
func (ϟa *GlActiveShaderProgramEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glActiveShaderProgramEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlActiveShaderProgramEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlActiveShaderProgramEXT)
}
var _ = atom.Atom(&GlAlphaFuncQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glAlphaFuncQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glAlphaFuncQCOM().
func (ϟa *GlAlphaFuncQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_alpha_test); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glAlphaFuncQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlAlphaFuncQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlAlphaFuncQCOM)
}
var _ = atom.Atom(&GlApplyFramebufferAttachmentCMAAINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glApplyFramebufferAttachmentCMAAINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glApplyFramebufferAttachmentCMAAINTEL().
func (ϟa *GlApplyFramebufferAttachmentCMAAINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_framebuffer_CMAA); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glApplyFramebufferAttachmentCMAAINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlApplyFramebufferAttachmentCMAAINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlApplyFramebufferAttachmentCMAAINTEL)
}
var _ = atom.Atom(&GlBeginConditionalRenderNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginConditionalRenderNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginConditionalRenderNV().
func (ϟa *GlBeginConditionalRenderNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_conditional_render); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginConditionalRenderNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginConditionalRenderNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlBeginConditionalRenderNV)
}
var _ = atom.Atom(&GlBeginPerfMonitorAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginPerfMonitorAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginPerfMonitorAMD().
func (ϟa *GlBeginPerfMonitorAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginPerfMonitorAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginPerfMonitorAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Monitor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBeginPerfMonitorAMD)
}
var _ = atom.Atom(&GlBeginPerfQueryINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginPerfQueryINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginPerfQueryINTEL().
func (ϟa *GlBeginPerfQueryINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginPerfQueryINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginPerfQueryINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryHandle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBeginPerfQueryINTEL)
}
var _ = atom.Atom(&GlBeginQueryEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginQueryEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginQueryEXT().
func (ϟa *GlBeginQueryEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginQueryEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginQueryEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBeginQueryEXT)
}
var _ = atom.Atom(&GlBindFragDataLocationEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindFragDataLocationEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindFragDataLocationEXT().
func (ϟa *GlBindFragDataLocationEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_blend_func_extended); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindFragDataLocationEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindFragDataLocationEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Color.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlBindFragDataLocationEXT)
}
var _ = atom.Atom(&GlBindFragDataLocationIndexedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindFragDataLocationIndexedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindFragDataLocationIndexedEXT().
func (ϟa *GlBindFragDataLocationIndexedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_blend_func_extended); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindFragDataLocationIndexedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindFragDataLocationIndexedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.ColorNumber.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlBindFragDataLocationIndexedEXT)
}
var _ = atom.Atom(&GlBindProgramPipelineEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindProgramPipelineEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindProgramPipelineEXT().
func (ϟa *GlBindProgramPipelineEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindProgramPipelineEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindProgramPipelineEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindProgramPipelineEXT)
}
var _ = atom.Atom(&GlBindVertexArrayOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindVertexArrayOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindVertexArrayOES().
func (ϟa *GlBindVertexArrayOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_vertex_array_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subBindVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindVertexArrayOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindVertexArrayOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindVertexArrayOES)
}
var _ = atom.Atom(&GlBlendBarrierNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendBarrierNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendBarrierNV().
func (ϟa *GlBlendBarrierNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_blend_equation_advanced); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendBarrier(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendBarrierNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendBarrierNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlBlendBarrierNV)
}
var _ = atom.Atom(&GlBlendEquationSeparateiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationSeparateiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationSeparateiOES().
func (ϟa *GlBlendEquationSeparateiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.ModeRGB, ϟa.ModeAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationSeparateiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationSeparateiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.ModeRGB))
ϟb.Push(value.U32(ϟa.ModeAlpha))
ϟb.Call(funcInfoGlBlendEquationSeparateiOES)
}
var _ = atom.Atom(&GlBlendEquationiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationiOES().
func (ϟa *GlBlendEquationiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Mode); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlBlendEquationiOES)
}
var _ = atom.Atom(&GlBlendFuncSeparateiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFuncSeparateiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFuncSeparateiOES().
func (ϟa *GlBlendFuncSeparateiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFuncSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.SrcRGB, ϟa.DstRGB, ϟa.SrcAlpha, ϟa.DstAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFuncSeparateiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFuncSeparateiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcRGB))
ϟb.Push(value.U32(ϟa.DstRGB))
ϟb.Push(value.U32(ϟa.SrcAlpha))
ϟb.Push(value.U32(ϟa.DstAlpha))
ϟb.Call(funcInfoGlBlendFuncSeparateiOES)
}
var _ = atom.Atom(&GlBlendFunciOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFunciOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFunciOES().
func (ϟa *GlBlendFunciOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFunci(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Src, ϟa.Dst); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFunciOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFunciOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Src))
ϟb.Push(value.U32(ϟa.Dst))
ϟb.Call(funcInfoGlBlendFunciOES)
}
var _ = atom.Atom(&GlBlendParameteriNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendParameteriNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendParameteriNV().
func (ϟa *GlBlendParameteriNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_blend_equation_advanced); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendParameteriNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendParameteriNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBlendParameteriNV)
}
var _ = atom.Atom(&GlBlitFramebufferANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlitFramebufferANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlitFramebufferANGLE().
func (ϟa *GlBlitFramebufferANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_framebuffer_blit); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlitFramebufferANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlitFramebufferANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY1.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Push(value.U32(ϟa.Filter))
ϟb.Call(funcInfoGlBlitFramebufferANGLE)
}
var _ = atom.Atom(&GlBlitFramebufferNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlitFramebufferNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlitFramebufferNV().
func (ϟa *GlBlitFramebufferNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_framebuffer_blit); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlitFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.SrcX0, ϟa.SrcY0, ϟa.SrcX1, ϟa.SrcY1, ϟa.DstX0, ϟa.DstY0, ϟa.DstX1, ϟa.DstY1, ϟa.Mask, ϟa.Filter); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlitFramebufferNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlitFramebufferNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY1.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Push(value.U32(ϟa.Filter))
ϟb.Call(funcInfoGlBlitFramebufferNV)
}
var _ = atom.Atom(&GlBufferStorageEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBufferStorageEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBufferStorageEXT().
func (ϟa *GlBufferStorageEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_buffer_storage); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBufferStorageEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBufferStorageEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Flag))
ϟb.Call(funcInfoGlBufferStorageEXT)
}
var _ = atom.Atom(&GlClientWaitSyncAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClientWaitSyncAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClientWaitSyncAPPLE().
// Upon returning the glClientWaitSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlClientWaitSyncAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟerr := subClientWaitSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.Flag, ϟa.Timeout); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClientWaitSyncAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glClientWaitSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlClientWaitSyncAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Flag))
ϟb.Push(ϟa.Timeout.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClientWaitSyncAPPLE)
}
var _ = atom.Atom(&GlColorMaskiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorMaskiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorMaskiOES().
func (ϟa *GlColorMaskiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed); ϟerr != nil {
return ϟerr
}
if ϟerr := subColorMaski(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.R, ϟa.G, ϟa.B, ϟa.A); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorMaskiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorMaskiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.G.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.A.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorMaskiOES)
}
var _ = atom.Atom(&GlCompressedTexImage3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexImage3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexImage3DOES().
func (ϟa *GlCompressedTexImage3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟerr := subCompressedTexImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Border, ϟa.ImageSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexImage3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexImage3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexImage3DOES)
}
var _ = atom.Atom(&GlCompressedTexSubImage3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexSubImage3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexSubImage3DOES().
func (ϟa *GlCompressedTexSubImage3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟerr := subCompressedTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Format, ϟa.ImageSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexSubImage3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexSubImage3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexSubImage3DOES)
}
var _ = atom.Atom(&GlCopyBufferSubDataNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyBufferSubDataNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyBufferSubDataNV().
func (ϟa *GlCopyBufferSubDataNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_copy_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyBufferSubData(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ReadTarget, ϟa.WriteTarget, ϟa.ReadOffset, ϟa.WriteOffset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyBufferSubDataNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyBufferSubDataNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.ReadTarget))
ϟb.Push(value.U32(ϟa.WriteTarget))
ϟb.Push(ϟa.ReadOffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.WriteOffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyBufferSubDataNV)
}
var _ = atom.Atom(&GlCopyImageSubDataOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyImageSubDataOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyImageSubDataOES().
func (ϟa *GlCopyImageSubDataOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_copy_image); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyImageSubData(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.SrcName, ϟa.SrcTarget, ϟa.SrcLevel, ϟa.SrcX, ϟa.SrcY, ϟa.SrcZ, ϟa.DstName, ϟa.DstTarget, ϟa.DstLevel, ϟa.DstX, ϟa.DstY, ϟa.DstZ, ϟa.SrcWidth, ϟa.SrcHeight, ϟa.SrcDepth); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyImageSubDataOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyImageSubDataOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcTarget))
ϟb.Push(ϟa.SrcLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.DstTarget))
ϟb.Push(ϟa.DstLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcWidth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcHeight.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcDepth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyImageSubDataOES)
}
var _ = atom.Atom(&GlCopyPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyPathNV().
func (ϟa *GlCopyPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.ResultPath.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcPath.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyPathNV)
}
var _ = atom.Atom(&GlCopyTexSubImage3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyTexSubImage3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyTexSubImage3DOES().
func (ϟa *GlCopyTexSubImage3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.X, ϟa.Y, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyTexSubImage3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyTexSubImage3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyTexSubImage3DOES)
}
var _ = atom.Atom(&GlCopyTextureLevelsAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyTextureLevelsAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyTextureLevelsAPPLE().
func (ϟa *GlCopyTextureLevelsAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_copy_texture_levels); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyTextureLevelsAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyTextureLevelsAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.DestinationTexture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SourceTexture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SourceBaseLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SourceLevelCount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyTextureLevelsAPPLE)
}
var _ = atom.Atom(&GlCoverFillPathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverFillPathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverFillPathInstancedNV().
func (ϟa *GlCoverFillPathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverFillPathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverFillPathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCoverFillPathInstancedNV)
}
var _ = atom.Atom(&GlCoverFillPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverFillPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverFillPathNV().
func (ϟa *GlCoverFillPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverFillPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverFillPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Call(funcInfoGlCoverFillPathNV)
}
var _ = atom.Atom(&GlCoverStrokePathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverStrokePathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverStrokePathInstancedNV().
func (ϟa *GlCoverStrokePathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverStrokePathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverStrokePathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCoverStrokePathInstancedNV)
}
var _ = atom.Atom(&GlCoverStrokePathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverStrokePathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverStrokePathNV().
func (ϟa *GlCoverStrokePathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverStrokePathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverStrokePathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Call(funcInfoGlCoverStrokePathNV)
}
var _ = atom.Atom(&GlCoverageMaskNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverageMaskNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverageMaskNV().
func (ϟa *GlCoverageMaskNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_coverage_sample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverageMaskNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverageMaskNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCoverageMaskNV)
}
var _ = atom.Atom(&GlCoverageModulationNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverageModulationNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverageModulationNV().
func (ϟa *GlCoverageModulationNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_framebuffer_mixed_samples); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverageModulationNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverageModulationNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Components))
ϟb.Call(funcInfoGlCoverageModulationNV)
}
var _ = atom.Atom(&GlCoverageModulationTableNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverageModulationTableNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverageModulationTableNV().
func (ϟa *GlCoverageModulationTableNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_framebuffer_mixed_samples); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverageModulationTableNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverageModulationTableNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCoverageModulationTableNV)
}
var _ = atom.Atom(&GlCoverageOperationNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCoverageOperationNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCoverageOperationNV().
func (ϟa *GlCoverageOperationNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_coverage_sample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCoverageOperationNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCoverageOperationNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Operation))
ϟb.Call(funcInfoGlCoverageOperationNV)
}
var _ = atom.Atom(&GlCreatePerfQueryINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCreatePerfQueryINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCreatePerfQueryINTEL().
func (ϟa *GlCreatePerfQueryINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCreatePerfQueryINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCreatePerfQueryINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.QueryHandle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCreatePerfQueryINTEL)
}
var _ = atom.Atom(&GlCreateShaderProgramvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCreateShaderProgramvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCreateShaderProgramvEXT().
// Upon returning the glCreateShaderProgramvEXT() return value will be stored on the stack.
func (ϟa *GlCreateShaderProgramvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCreateShaderProgramvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCreateShaderProgramvEXT() return value will be stored on the stack.
func (ϟa *GlCreateShaderProgramvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Strings.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCreateShaderProgramvEXT)
}
var _ = atom.Atom(&GlDeleteFencesNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteFencesNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteFencesNV().
func (ϟa *GlDeleteFencesNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteFencesNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteFencesNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fences.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteFencesNV)
}
var _ = atom.Atom(&GlDeletePathsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeletePathsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeletePathsNV().
func (ϟa *GlDeletePathsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeletePathsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeletePathsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Range.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeletePathsNV)
}
var _ = atom.Atom(&GlDeletePerfMonitorsAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeletePerfMonitorsAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeletePerfMonitorsAMD().
func (ϟa *GlDeletePerfMonitorsAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeletePerfMonitorsAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeletePerfMonitorsAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Monitors.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeletePerfMonitorsAMD)
}
var _ = atom.Atom(&GlDeletePerfQueryINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeletePerfQueryINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeletePerfQueryINTEL().
func (ϟa *GlDeletePerfQueryINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeletePerfQueryINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeletePerfQueryINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryHandle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeletePerfQueryINTEL)
}
var _ = atom.Atom(&GlDeleteProgramPipelinesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteProgramPipelinesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteProgramPipelinesEXT().
func (ϟa *GlDeleteProgramPipelinesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteProgramPipelinesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteProgramPipelinesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pipelines.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteProgramPipelinesEXT)
}
var _ = atom.Atom(&GlDeleteQueriesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteQueriesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteQueriesEXT().
func (ϟa *GlDeleteQueriesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
q := ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := q.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (QueryId(uint32(0))) {
delete(ctx.Instances.Queries, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteQueriesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteQueriesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Queries.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteQueriesEXT)
}
var _ = atom.Atom(&GlDeleteSyncAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteSyncAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteSyncAPPLE().
func (ϟa *GlDeleteSyncAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟerr := subDeleteSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteSyncAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteSyncAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteSyncAPPLE)
}
var _ = atom.Atom(&GlDeleteVertexArraysOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteVertexArraysOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteVertexArraysOES().
func (ϟa *GlDeleteVertexArraysOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_vertex_array_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subDeleteVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.Arrays); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteVertexArraysOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteVertexArraysOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Arrays.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteVertexArraysOES)
}
var _ = atom.Atom(&GlDepthRangeArrayfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangeArrayfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangeArrayfvNV().
func (ϟa *GlDepthRangeArrayfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangeArrayfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangeArrayfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangeArrayfvNV)
}
var _ = atom.Atom(&GlDepthRangeIndexedfNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangeIndexedfNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangeIndexedfNV().
func (ϟa *GlDepthRangeIndexedfNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangeIndexedfNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangeIndexedfNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangeIndexedfNV)
}
var _ = atom.Atom(&GlDisableDriverControlQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableDriverControlQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableDriverControlQCOM().
func (ϟa *GlDisableDriverControlQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_driver_control); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableDriverControlQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableDriverControlQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.DriverControl.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableDriverControlQCOM)
}
var _ = atom.Atom(&GlDisableiNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableiNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableiNV().
func (ϟa *GlDisableiNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subDisablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableiNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableiNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableiNV)
}
var _ = atom.Atom(&GlDisableiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableiOES().
func (ϟa *GlDisableiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subDisablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableiOES)
}
var _ = atom.Atom(&GlDiscardFramebufferEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDiscardFramebufferEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDiscardFramebufferEXT().
func (ϟa *GlDiscardFramebufferEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_discard_framebuffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subInvalidateFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.NumAttachments, ϟa.Attachments); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDiscardFramebufferEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDiscardFramebufferEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.NumAttachments.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Attachments.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDiscardFramebufferEXT)
}
var _ = atom.Atom(&GlDrawArraysInstancedANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysInstancedANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysInstancedANGLE().
func (ϟa *GlDrawArraysInstancedANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawArraysInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.First, ϟa.Count, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysInstancedANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysInstancedANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysInstancedANGLE)
}
var _ = atom.Atom(&GlDrawArraysInstancedBaseInstanceEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysInstancedBaseInstanceEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysInstancedBaseInstanceEXT().
func (ϟa *GlDrawArraysInstancedBaseInstanceEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_base_instance); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysInstancedBaseInstanceEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysInstancedBaseInstanceEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Baseinstance.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysInstancedBaseInstanceEXT)
}
var _ = atom.Atom(&GlDrawArraysInstancedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysInstancedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysInstancedEXT().
func (ϟa *GlDrawArraysInstancedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_instanced, ExtensionId_GL_EXT_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawArraysInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Start, ϟa.Count, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysInstancedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysInstancedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysInstancedEXT)
}
var _ = atom.Atom(&GlDrawArraysInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawArraysInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawArraysInstancedNV().
func (ϟa *GlDrawArraysInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_draw_instanced); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawArraysInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.First, ϟa.Count, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawArraysInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawArraysInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawArraysInstancedNV)
}
var _ = atom.Atom(&GlDrawBuffersEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawBuffersEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawBuffersEXT().
func (ϟa *GlDrawBuffersEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_buffers); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawBuffers(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.N, ϟa.Bufs); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawBuffersEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawBuffersEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Bufs.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawBuffersEXT)
}
var _ = atom.Atom(&GlDrawBuffersIndexedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawBuffersIndexedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawBuffersIndexedEXT().
func (ϟa *GlDrawBuffersIndexedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multiview_draw_buffers); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawBuffersIndexedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawBuffersIndexedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawBuffersIndexedEXT)
}
var _ = atom.Atom(&GlDrawBuffersNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawBuffersNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawBuffersNV().
func (ϟa *GlDrawBuffersNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_draw_buffers); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawBuffers(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.N, ϟa.Bufs); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawBuffersNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawBuffersNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Bufs.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawBuffersNV)
}
var _ = atom.Atom(&GlDrawElementsBaseVertexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsBaseVertexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsBaseVertexEXT().
func (ϟa *GlDrawElementsBaseVertexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsBaseVertexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsBaseVertexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsBaseVertexEXT)
}
var _ = atom.Atom(&GlDrawElementsBaseVertexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsBaseVertexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsBaseVertexOES().
func (ϟa *GlDrawElementsBaseVertexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsBaseVertexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsBaseVertexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsBaseVertexOES)
}
var _ = atom.Atom(&GlDrawElementsInstancedANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedANGLE().
func (ϟa *GlDrawElementsInstancedANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedANGLE)
}
var _ = atom.Atom(&GlDrawElementsInstancedBaseInstanceEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedBaseInstanceEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedBaseInstanceEXT().
func (ϟa *GlDrawElementsInstancedBaseInstanceEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_base_instance); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedBaseInstanceEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedBaseInstanceEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Baseinstance.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedBaseInstanceEXT)
}
var _ = atom.Atom(&GlDrawElementsInstancedBaseVertexBaseInstanceEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedBaseVertexBaseInstanceEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedBaseVertexBaseInstanceEXT().
func (ϟa *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_base_instance); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedBaseVertexBaseInstanceEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Baseinstance.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedBaseVertexBaseInstanceEXT)
}
var _ = atom.Atom(&GlDrawElementsInstancedBaseVertexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedBaseVertexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedBaseVertexEXT().
func (ϟa *GlDrawElementsInstancedBaseVertexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstancedBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Instancecount, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedBaseVertexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedBaseVertexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedBaseVertexEXT)
}
var _ = atom.Atom(&GlDrawElementsInstancedBaseVertexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedBaseVertexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedBaseVertexOES().
func (ϟa *GlDrawElementsInstancedBaseVertexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstancedBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Instancecount, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedBaseVertexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedBaseVertexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedBaseVertexOES)
}
var _ = atom.Atom(&GlDrawElementsInstancedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedEXT().
func (ϟa *GlDrawElementsInstancedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_instanced, ExtensionId_GL_EXT_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedEXT)
}
var _ = atom.Atom(&GlDrawElementsInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawElementsInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawElementsInstancedNV().
func (ϟa *GlDrawElementsInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_draw_instanced); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawElementsInstanced(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Primcount); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawElementsInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawElementsInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawElementsInstancedNV)
}
var _ = atom.Atom(&GlDrawRangeElementsBaseVertexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawRangeElementsBaseVertexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawRangeElementsBaseVertexEXT().
func (ϟa *GlDrawRangeElementsBaseVertexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawRangeElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Start, ϟa.End, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawRangeElementsBaseVertexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawRangeElementsBaseVertexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.End.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawRangeElementsBaseVertexEXT)
}
var _ = atom.Atom(&GlDrawRangeElementsBaseVertexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawRangeElementsBaseVertexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawRangeElementsBaseVertexOES().
func (ϟa *GlDrawRangeElementsBaseVertexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawRangeElementsBaseVertex(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode, ϟa.Start, ϟa.End, ϟa.Count, ϟa.Type, ϟa.Indices, ϟa.Basevertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawRangeElementsBaseVertexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawRangeElementsBaseVertexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.End.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawRangeElementsBaseVertexOES)
}
var _ = atom.Atom(&GlEGLImageTargetRenderbufferStorageOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEGLImageTargetRenderbufferStorageOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEGLImageTargetRenderbufferStorageOES().
func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_EGL_image); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEGLImageTargetRenderbufferStorageOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Image.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEGLImageTargetRenderbufferStorageOES)
}
var _ = atom.Atom(&GlEGLImageTargetTexture2DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEGLImageTargetTexture2DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEGLImageTargetTexture2DOES().
func (ϟa *GlEGLImageTargetTexture2DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_EGL_image); ϟerr != nil {
return ϟerr
}
if (ϟa.Target) != (GLenum_GL_TEXTURE_2D) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟc.EGLImages.Contains(EGLImageKHR(ϟa.Image)) {
info := ϟc.EGLImages.Get(EGLImageKHR(ϟa.Image))
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
fmt := GLenum_GL_RGB
ty := GLenum_GL_UNSIGNED_BYTE
t.OnAccess(ϟs).TexelFormat = fmt
t.OnAccess(ϟs).TexelType = ty
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, info.Width, info.Height, fmt, ty)
if ϟerr != nil {
return ϟerr
}
t.OnAccess(ϟs).Texture2D[GLint(int32(0))] = Image{Width: GLsizei(info.Width), Height: GLsizei(info.Height), Size: _res_0, TexelFormat: fmt, TexelType: ty}
t.OnAccess(ϟs).EGLImage = ϟa.Image
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEGLImageTargetTexture2DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEGLImageTargetTexture2DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Image.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEGLImageTargetTexture2DOES)
}
var _ = atom.Atom(&GlEnableDriverControlQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableDriverControlQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableDriverControlQCOM().
func (ϟa *GlEnableDriverControlQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_driver_control); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableDriverControlQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableDriverControlQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.DriverControl.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableDriverControlQCOM)
}
var _ = atom.Atom(&GlEnableiNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableiNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableiNV().
func (ϟa *GlEnableiNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subEnablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableiNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableiNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableiNV)
}
var _ = atom.Atom(&GlEnableiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableiOES().
func (ϟa *GlEnableiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subEnablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableiOES)
}
var _ = atom.Atom(&GlEndConditionalRenderNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndConditionalRenderNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndConditionalRenderNV().
func (ϟa *GlEndConditionalRenderNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_conditional_render); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndConditionalRenderNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndConditionalRenderNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlEndConditionalRenderNV)
}
var _ = atom.Atom(&GlEndPerfMonitorAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndPerfMonitorAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndPerfMonitorAMD().
func (ϟa *GlEndPerfMonitorAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndPerfMonitorAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndPerfMonitorAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Monitor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEndPerfMonitorAMD)
}
var _ = atom.Atom(&GlEndPerfQueryINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndPerfQueryINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndPerfQueryINTEL().
func (ϟa *GlEndPerfQueryINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndPerfQueryINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndPerfQueryINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryHandle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEndPerfQueryINTEL)
}
var _ = atom.Atom(&GlEndQueryEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndQueryEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndQueryEXT().
func (ϟa *GlEndQueryEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndQueryEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndQueryEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlEndQueryEXT)
}
var _ = atom.Atom(&GlEndTilingQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndTilingQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndTilingQCOM().
func (ϟa *GlEndTilingQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_tiled_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndTilingQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndTilingQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.PreserveMask))
ϟb.Call(funcInfoGlEndTilingQCOM)
}
var _ = atom.Atom(&GlExtGetBufferPointervQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetBufferPointervQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetBufferPointervQCOM().
func (ϟa *GlExtGetBufferPointervQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetBufferPointervQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetBufferPointervQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetBufferPointervQCOM)
}
var _ = atom.Atom(&GlExtGetBuffersQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetBuffersQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetBuffersQCOM().
func (ϟa *GlExtGetBuffersQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetBuffersQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetBuffersQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxBuffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumBuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetBuffersQCOM)
}
var _ = atom.Atom(&GlExtGetFramebuffersQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetFramebuffersQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetFramebuffersQCOM().
func (ϟa *GlExtGetFramebuffersQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetFramebuffersQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetFramebuffersQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Framebuffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxFramebuffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumFramebuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetFramebuffersQCOM)
}
var _ = atom.Atom(&GlExtGetProgramBinarySourceQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetProgramBinarySourceQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetProgramBinarySourceQCOM().
func (ϟa *GlExtGetProgramBinarySourceQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetProgramBinarySourceQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetProgramBinarySourceQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Shadertype))
ϟb.Push(ϟa.Source.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetProgramBinarySourceQCOM)
}
var _ = atom.Atom(&GlExtGetProgramsQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetProgramsQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetProgramsQCOM().
func (ϟa *GlExtGetProgramsQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetProgramsQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetProgramsQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Programs.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxPrograms.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumPrograms.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetProgramsQCOM)
}
var _ = atom.Atom(&GlExtGetRenderbuffersQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetRenderbuffersQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetRenderbuffersQCOM().
func (ϟa *GlExtGetRenderbuffersQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetRenderbuffersQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetRenderbuffersQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Renderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxRenderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumRenderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetRenderbuffersQCOM)
}
var _ = atom.Atom(&GlExtGetShadersQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetShadersQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetShadersQCOM().
func (ϟa *GlExtGetShadersQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetShadersQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetShadersQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Shaders.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxShaders.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumShaders.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetShadersQCOM)
}
var _ = atom.Atom(&GlExtGetTexLevelParameterivQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetTexLevelParameterivQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetTexLevelParameterivQCOM().
func (ϟa *GlExtGetTexLevelParameterivQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetTexLevelParameterivQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetTexLevelParameterivQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetTexLevelParameterivQCOM)
}
var _ = atom.Atom(&GlExtGetTexSubImageQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetTexSubImageQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetTexSubImageQCOM().
func (ϟa *GlExtGetTexSubImageQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetTexSubImageQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetTexSubImageQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Texels.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetTexSubImageQCOM)
}
var _ = atom.Atom(&GlExtGetTexturesQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtGetTexturesQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtGetTexturesQCOM().
func (ϟa *GlExtGetTexturesQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtGetTexturesQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtGetTexturesQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Textures.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxTextures.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumTextures.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtGetTexturesQCOM)
}
var _ = atom.Atom(&GlExtIsProgramBinaryQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtIsProgramBinaryQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtIsProgramBinaryQCOM().
// Upon returning the glExtIsProgramBinaryQCOM() return value will be stored on the stack.
func (ϟa *GlExtIsProgramBinaryQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtIsProgramBinaryQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glExtIsProgramBinaryQCOM() return value will be stored on the stack.
func (ϟa *GlExtIsProgramBinaryQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlExtIsProgramBinaryQCOM)
}
var _ = atom.Atom(&GlExtTexObjectStateOverrideiQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glExtTexObjectStateOverrideiQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glExtTexObjectStateOverrideiQCOM().
func (ϟa *GlExtTexObjectStateOverrideiQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_extended_get); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glExtTexObjectStateOverrideiQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlExtTexObjectStateOverrideiQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlExtTexObjectStateOverrideiQCOM)
}
var _ = atom.Atom(&GlFenceSyncAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFenceSyncAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFenceSyncAPPLE().
// Upon returning the glFenceSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlFenceSyncAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
sync := ϟa.Result
if ϟerr := subFenceSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Condition, ϟa.Flag, sync); ϟerr != nil {
return ϟerr
}
_ = sync
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFenceSyncAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glFenceSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlFenceSyncAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Condition))
ϟb.Push(value.U32(ϟa.Flag))
ϟb.Call(funcInfoGlFenceSyncAPPLE)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(ϟs.MemoryLayout.PointerSize))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlFinishFenceNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFinishFenceNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFinishFenceNV().
func (ϟa *GlFinishFenceNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFinishFenceNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFinishFenceNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Fence.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFinishFenceNV)
}
var _ = atom.Atom(&GlFlushMappedBufferRangeEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFlushMappedBufferRangeEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFlushMappedBufferRangeEXT().
func (ϟa *GlFlushMappedBufferRangeEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_map_buffer_range); ϟerr != nil {
return ϟerr
}
if ϟerr := subFlushMappedBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Offset, ϟa.Length); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFlushMappedBufferRangeEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFlushMappedBufferRangeEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFlushMappedBufferRangeEXT)
}
var _ = atom.Atom(&GlFragmentCoverageColorNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFragmentCoverageColorNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFragmentCoverageColorNV().
func (ϟa *GlFragmentCoverageColorNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fragment_coverage_to_color); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFragmentCoverageColorNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFragmentCoverageColorNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Color.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFragmentCoverageColorNV)
}
var _ = atom.Atom(&GlFramebufferSampleLocationsfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferSampleLocationsfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferSampleLocationsfvNV().
func (ϟa *GlFramebufferSampleLocationsfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_sample_locations); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferSampleLocationsfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferSampleLocationsfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferSampleLocationsfvNV)
}
var _ = atom.Atom(&GlFramebufferTexture2DMultisampleEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture2DMultisampleEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture2DMultisampleEXT().
func (ϟa *GlFramebufferTexture2DMultisampleEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multisampled_render_to_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture2D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, ϟa.Textarget, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture2DMultisampleEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture2DMultisampleEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Textarget))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture2DMultisampleEXT)
}
var _ = atom.Atom(&GlFramebufferTexture2DMultisampleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture2DMultisampleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture2DMultisampleIMG().
func (ϟa *GlFramebufferTexture2DMultisampleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_multisampled_render_to_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture2DMultisampleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture2DMultisampleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Textarget))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture2DMultisampleIMG)
}
var _ = atom.Atom(&GlFramebufferTexture3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture3DOES().
func (ϟa *GlFramebufferTexture3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Textarget))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture3DOES)
}
var _ = atom.Atom(&GlFramebufferTextureMultiviewOVR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureMultiviewOVR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureMultiviewOVR().
func (ϟa *GlFramebufferTextureMultiviewOVR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OVR_multiview); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureMultiviewOVR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureMultiviewOVR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseViewIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumViews.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureMultiviewOVR)
}
var _ = atom.Atom(&GlFramebufferTextureOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureOES().
func (ϟa *GlFramebufferTextureOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_geometry_shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureOES)
}
var _ = atom.Atom(&GlGenFencesNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenFencesNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenFencesNV().
func (ϟa *GlGenFencesNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenFencesNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenFencesNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fences.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenFencesNV)
}
var _ = atom.Atom(&GlGenPathsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenPathsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenPathsNV().
// Upon returning the glGenPathsNV() return value will be stored on the stack.
func (ϟa *GlGenPathsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenPathsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGenPathsNV() return value will be stored on the stack.
func (ϟa *GlGenPathsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Range.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenPathsNV)
}
var _ = atom.Atom(&GlGenPerfMonitorsAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenPerfMonitorsAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenPerfMonitorsAMD().
func (ϟa *GlGenPerfMonitorsAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenPerfMonitorsAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenPerfMonitorsAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Monitors.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenPerfMonitorsAMD)
}
var _ = atom.Atom(&GlGenProgramPipelinesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenProgramPipelinesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenProgramPipelinesEXT().
func (ϟa *GlGenProgramPipelinesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenProgramPipelinesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenProgramPipelinesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pipelines.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenProgramPipelinesEXT)
}
var _ = atom.Atom(&GlGenQueriesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenQueriesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenQueriesEXT().
func (ϟa *GlGenQueriesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
q := ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := QueryId(ϟa.Queries.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Queries[id] = &Query{}
q.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenQueriesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenQueriesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Queries.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenQueriesEXT)
}
var _ = atom.Atom(&GlGenVertexArraysOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenVertexArraysOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenVertexArraysOES().
func (ϟa *GlGenVertexArraysOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_vertex_array_object); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGenVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.Arrays); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenVertexArraysOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenVertexArraysOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Arrays.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenVertexArraysOES)
}
var _ = atom.Atom(&GlGetBufferPointervOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBufferPointervOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBufferPointervOES().
func (ϟa *GlGetBufferPointervOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_mapbuffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetBufferPointerv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBufferPointervOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBufferPointervOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBufferPointervOES)
}
var _ = atom.Atom(&GlGetCoverageModulationTableNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetCoverageModulationTableNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetCoverageModulationTableNV().
func (ϟa *GlGetCoverageModulationTableNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_framebuffer_mixed_samples); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetCoverageModulationTableNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetCoverageModulationTableNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Bufsize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetCoverageModulationTableNV)
}
var _ = atom.Atom(&GlGetDriverControlStringQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetDriverControlStringQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetDriverControlStringQCOM().
func (ϟa *GlGetDriverControlStringQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_driver_control); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetDriverControlStringQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetDriverControlStringQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.DriverControl.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DriverControlString.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetDriverControlStringQCOM)
}
var _ = atom.Atom(&GlGetDriverControlsQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetDriverControlsQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetDriverControlsQCOM().
func (ϟa *GlGetDriverControlsQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_driver_control); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetDriverControlsQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetDriverControlsQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Num.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DriverControls.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetDriverControlsQCOM)
}
var _ = atom.Atom(&GlGetFenceivNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFenceivNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFenceivNV().
func (ϟa *GlGetFenceivNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFenceivNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFenceivNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Fence.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFenceivNV)
}
var _ = atom.Atom(&GlGetFirstPerfQueryIdINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFirstPerfQueryIdINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFirstPerfQueryIdINTEL().
func (ϟa *GlGetFirstPerfQueryIdINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFirstPerfQueryIdINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFirstPerfQueryIdINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFirstPerfQueryIdINTEL)
}
var _ = atom.Atom(&GlGetFloati_vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFloati_vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFloati_vNV().
func (ϟa *GlGetFloati_vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFloati_vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFloati_vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFloati_vNV)
}
var _ = atom.Atom(&GlGetFragDataIndexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFragDataIndexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFragDataIndexEXT().
// Upon returning the glGetFragDataIndexEXT() return value will be stored on the stack.
func (ϟa *GlGetFragDataIndexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_blend_func_extended); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFragDataIndexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetFragDataIndexEXT() return value will be stored on the stack.
func (ϟa *GlGetFragDataIndexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetFragDataIndexEXT)
}
var _ = atom.Atom(&GlGetGraphicsResetStatusEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetGraphicsResetStatusEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetGraphicsResetStatusEXT().
// Upon returning the glGetGraphicsResetStatusEXT() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatusEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetGraphicsResetStatusEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetGraphicsResetStatusEXT() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatusEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlGetGraphicsResetStatusEXT)
}
var _ = atom.Atom(&GlGetGraphicsResetStatusKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetGraphicsResetStatusKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetGraphicsResetStatusKHR().
// Upon returning the glGetGraphicsResetStatusKHR() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatusKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_robustness); ϟerr != nil {
return ϟerr
}
if ϟerr := subGetGraphicsResetStatus(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetGraphicsResetStatusKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetGraphicsResetStatusKHR() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatusKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlGetGraphicsResetStatusKHR)
}
var _ = atom.Atom(&GlGetImageHandleNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetImageHandleNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetImageHandleNV().
// Upon returning the glGetImageHandleNV() return value will be stored on the stack.
func (ϟa *GlGetImageHandleNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetImageHandleNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetImageHandleNV() return value will be stored on the stack.
func (ϟa *GlGetImageHandleNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layered.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layer.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Call(funcInfoGlGetImageHandleNV)
}
var _ = atom.Atom(&GlGetInteger64vAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetInteger64vAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetInteger64vAPPLE().
func (ϟa *GlGetInteger64vAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetInteger64v(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetInteger64vAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetInteger64vAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetInteger64vAPPLE)
}
var _ = atom.Atom(&GlGetIntegeri_vEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetIntegeri_vEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetIntegeri_vEXT().
func (ϟa *GlGetIntegeri_vEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multiview_draw_buffers); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetIntegeri_vEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetIntegeri_vEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetIntegeri_vEXT)
}
var _ = atom.Atom(&GlGetInternalformatSampleivNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetInternalformatSampleivNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetInternalformatSampleivNV().
func (ϟa *GlGetInternalformatSampleivNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_internalformat_sample_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetInternalformatSampleivNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetInternalformatSampleivNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetInternalformatSampleivNV)
}
var _ = atom.Atom(&GlGetNextPerfQueryIdINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetNextPerfQueryIdINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetNextPerfQueryIdINTEL().
func (ϟa *GlGetNextPerfQueryIdINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetNextPerfQueryIdINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetNextPerfQueryIdINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NextQueryId.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetNextPerfQueryIdINTEL)
}
var _ = atom.Atom(&GlGetObjectLabelEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetObjectLabelEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetObjectLabelEXT().
func (ϟa *GlGetObjectLabelEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_debug_label); ϟerr != nil {
return ϟerr
}
switch ϟa.Type {
case GLenum_GL_TEXTURE, GLenum_GL_FRAMEBUFFER, GLenum_GL_RENDERBUFFER, GLenum_GL_BUFFER_OBJECT_EXT, GLenum_GL_SHADER_OBJECT_EXT, GLenum_GL_PROGRAM_OBJECT_EXT, GLenum_GL_VERTEX_ARRAY_OBJECT_EXT, GLenum_GL_QUERY_OBJECT_EXT, GLenum_GL_SAMPLER, GLenum_GL_TRANSFORM_FEEDBACK, GLenum_GL_PROGRAM_PIPELINE_OBJECT_EXT:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
_ = ϟa.Object
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufSize, ϟa.Length, ϟa.Label); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetObjectLabelEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetObjectLabelEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Object.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetObjectLabelEXT)
}
var _ = atom.Atom(&GlGetPathCommandsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathCommandsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathCommandsNV().
func (ϟa *GlGetPathCommandsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathCommandsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathCommandsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Commands.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathCommandsNV)
}
var _ = atom.Atom(&GlGetPathCoordsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathCoordsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathCoordsNV().
func (ϟa *GlGetPathCoordsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathCoordsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathCoordsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathCoordsNV)
}
var _ = atom.Atom(&GlGetPathDashArrayNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathDashArrayNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathDashArrayNV().
func (ϟa *GlGetPathDashArrayNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathDashArrayNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathDashArrayNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DashArray.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathDashArrayNV)
}
var _ = atom.Atom(&GlGetPathLengthNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathLengthNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathLengthNV().
// Upon returning the glGetPathLengthNV() return value will be stored on the stack.
func (ϟa *GlGetPathLengthNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathLengthNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetPathLengthNV() return value will be stored on the stack.
func (ϟa *GlGetPathLengthNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.StartSegment.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumSegments.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathLengthNV)
}
var _ = atom.Atom(&GlGetPathMetricRangeNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathMetricRangeNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathMetricRangeNV().
func (ϟa *GlGetPathMetricRangeNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathMetricRangeNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathMetricRangeNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MetricQueryMask))
ϟb.Push(ϟa.FirstPathName.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Metrics.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathMetricRangeNV)
}
var _ = atom.Atom(&GlGetPathMetricsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathMetricsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathMetricsNV().
func (ϟa *GlGetPathMetricsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathMetricsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathMetricsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MetricQueryMask))
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Metrics.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathMetricsNV)
}
var _ = atom.Atom(&GlGetPathParameterfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathParameterfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathParameterfvNV().
func (ϟa *GlGetPathParameterfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathParameterfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathParameterfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathParameterfvNV)
}
var _ = atom.Atom(&GlGetPathParameterivNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathParameterivNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathParameterivNV().
func (ϟa *GlGetPathParameterivNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathParameterivNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathParameterivNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathParameterivNV)
}
var _ = atom.Atom(&GlGetPathSpacingNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPathSpacingNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPathSpacingNV().
func (ϟa *GlGetPathSpacingNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPathSpacingNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPathSpacingNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.PathListMode))
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.AdvanceScale.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.KerningScale.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.ReturnedSpacing.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPathSpacingNV)
}
var _ = atom.Atom(&GlGetPerfCounterInfoINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfCounterInfoINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfCounterInfoINTEL().
func (ϟa *GlGetPerfCounterInfoINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfCounterInfoINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfCounterInfoINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterId.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterNameLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterName.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterDescLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterDesc.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterOffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterDataSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterTypeEnum.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterDataTypeEnum.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.RawCounterMaxValue.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfCounterInfoINTEL)
}
var _ = atom.Atom(&GlGetPerfMonitorCounterDataAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorCounterDataAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorCounterDataAMD().
func (ϟa *GlGetPerfMonitorCounterDataAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorCounterDataAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorCounterDataAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Monitor.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.DataSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorCounterDataAMD)
}
var _ = atom.Atom(&GlGetPerfMonitorCounterInfoAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorCounterInfoAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorCounterInfoAMD().
func (ϟa *GlGetPerfMonitorCounterInfoAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorCounterInfoAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorCounterInfoAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Group.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Counter.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorCounterInfoAMD)
}
var _ = atom.Atom(&GlGetPerfMonitorCounterStringAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorCounterStringAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorCounterStringAMD().
func (ϟa *GlGetPerfMonitorCounterStringAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorCounterStringAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorCounterStringAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Group.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Counter.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterString.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorCounterStringAMD)
}
var _ = atom.Atom(&GlGetPerfMonitorCountersAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorCountersAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorCountersAMD().
func (ϟa *GlGetPerfMonitorCountersAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorCountersAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorCountersAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Group.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCounters.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxActiveCounters.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Counters.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorCountersAMD)
}
var _ = atom.Atom(&GlGetPerfMonitorGroupStringAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorGroupStringAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorGroupStringAMD().
func (ϟa *GlGetPerfMonitorGroupStringAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorGroupStringAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorGroupStringAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Group.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.GroupString.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorGroupStringAMD)
}
var _ = atom.Atom(&GlGetPerfMonitorGroupsAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfMonitorGroupsAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfMonitorGroupsAMD().
func (ϟa *GlGetPerfMonitorGroupsAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfMonitorGroupsAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfMonitorGroupsAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumGroups.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.GroupsSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Groups.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfMonitorGroupsAMD)
}
var _ = atom.Atom(&GlGetPerfQueryDataINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfQueryDataINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfQueryDataINTEL().
func (ϟa *GlGetPerfQueryDataINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfQueryDataINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfQueryDataINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryHandle.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Flag.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DataSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfQueryDataINTEL)
}
var _ = atom.Atom(&GlGetPerfQueryIdByNameINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfQueryIdByNameINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfQueryIdByNameINTEL().
func (ϟa *GlGetPerfQueryIdByNameINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfQueryIdByNameINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfQueryIdByNameINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryName.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfQueryIdByNameINTEL)
}
var _ = atom.Atom(&GlGetPerfQueryInfoINTEL{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetPerfQueryInfoINTEL.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetPerfQueryInfoINTEL().
func (ϟa *GlGetPerfQueryInfoINTEL) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_INTEL_performance_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetPerfQueryInfoINTEL().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetPerfQueryInfoINTEL) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.QueryId.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.QueryNameLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.QueryName.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DataSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NoCounters.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NoInstances.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CapsMask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetPerfQueryInfoINTEL)
}
var _ = atom.Atom(&GlGetProgramBinaryOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramBinaryOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramBinaryOES().
func (ϟa *GlGetProgramBinaryOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_get_program_binary); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetProgramBinary(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.BufferSize, ϟa.BytesWritten, ϟa.BinaryFormat, ϟa.Binary); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramBinaryOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramBinaryOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BinaryFormat.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Binary.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramBinaryOES)
}
var _ = atom.Atom(&GlGetProgramPipelineInfoLogEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramPipelineInfoLogEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramPipelineInfoLogEXT().
func (ϟa *GlGetProgramPipelineInfoLogEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramPipelineInfoLogEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramPipelineInfoLogEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.InfoLog.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramPipelineInfoLogEXT)
}
var _ = atom.Atom(&GlGetProgramPipelineivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramPipelineivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramPipelineivEXT().
func (ϟa *GlGetProgramPipelineivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramPipelineivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramPipelineivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramPipelineivEXT)
}
var _ = atom.Atom(&GlGetProgramResourceLocationIndexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourceLocationIndexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourceLocationIndexEXT().
// Upon returning the glGetProgramResourceLocationIndexEXT() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceLocationIndexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_blend_func_extended); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourceLocationIndexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetProgramResourceLocationIndexEXT() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceLocationIndexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetProgramResourceLocationIndexEXT)
}
var _ = atom.Atom(&GlGetProgramResourcefvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourcefvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourcefvNV().
func (ϟa *GlGetProgramResourcefvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourcefvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramResourcefvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PropCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Props.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramResourcefvNV)
}
var _ = atom.Atom(&GlGetQueryObjecti64vEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjecti64vEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjecti64vEXT().
func (ϟa *GlGetQueryObjecti64vEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjecti64vEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjecti64vEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjecti64vEXT)
}
var _ = atom.Atom(&GlGetQueryObjectivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjectivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjectivEXT().
func (ϟa *GlGetQueryObjectivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjectivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjectivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjectivEXT)
}
var _ = atom.Atom(&GlGetQueryObjectui64vEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjectui64vEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjectui64vEXT().
func (ϟa *GlGetQueryObjectui64vEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjectui64vEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjectui64vEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjectui64vEXT)
}
var _ = atom.Atom(&GlGetQueryObjectuivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjectuivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjectuivEXT().
func (ϟa *GlGetQueryObjectuivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjectuivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjectuivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjectuivEXT)
}
var _ = atom.Atom(&GlGetQueryivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryivEXT().
func (ϟa *GlGetQueryivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryivEXT)
}
var _ = atom.Atom(&GlGetSamplerParameterIivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIivOES().
func (ϟa *GlGetSamplerParameterIivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIivOES)
}
var _ = atom.Atom(&GlGetSamplerParameterIuivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIuivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIuivOES().
func (ϟa *GlGetSamplerParameterIuivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIuivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIuivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIuivOES)
}
var _ = atom.Atom(&GlGetSyncivAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSyncivAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSyncivAPPLE().
func (ϟa *GlGetSyncivAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSynciv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.Pname, ϟa.BufSize, ϟa.Length, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSyncivAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSyncivAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSyncivAPPLE)
}
var _ = atom.Atom(&GlGetTexParameterIivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIivOES().
func (ϟa *GlGetTexParameterIivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIivOES)
}
var _ = atom.Atom(&GlGetTexParameterIuivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIuivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIuivOES().
func (ϟa *GlGetTexParameterIuivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIuivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIuivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIuivOES)
}
var _ = atom.Atom(&GlGetTextureHandleNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTextureHandleNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTextureHandleNV().
// Upon returning the glGetTextureHandleNV() return value will be stored on the stack.
func (ϟa *GlGetTextureHandleNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTextureHandleNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetTextureHandleNV() return value will be stored on the stack.
func (ϟa *GlGetTextureHandleNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlGetTextureHandleNV)
}
var _ = atom.Atom(&GlGetTextureSamplerHandleNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTextureSamplerHandleNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTextureSamplerHandleNV().
// Upon returning the glGetTextureSamplerHandleNV() return value will be stored on the stack.
func (ϟa *GlGetTextureSamplerHandleNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTextureSamplerHandleNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetTextureSamplerHandleNV() return value will be stored on the stack.
func (ϟa *GlGetTextureSamplerHandleNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTextureSamplerHandleNV)
}
var _ = atom.Atom(&GlGetTranslatedShaderSourceANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTranslatedShaderSourceANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTranslatedShaderSourceANGLE().
func (ϟa *GlGetTranslatedShaderSourceANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_translated_shader_source); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTranslatedShaderSourceANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTranslatedShaderSourceANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Bufsize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Source.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTranslatedShaderSourceANGLE)
}
var _ = atom.Atom(&GlGetnUniformfvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformfvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformfvEXT().
func (ϟa *GlGetnUniformfvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformfvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformfvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformfvEXT)
}
var _ = atom.Atom(&GlGetnUniformfvKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformfvKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformfvKHR().
func (ϟa *GlGetnUniformfvKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformfv_GLfloat__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformfvKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformfvKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformfvKHR)
}
var _ = atom.Atom(&GlGetnUniformivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformivEXT().
func (ϟa *GlGetnUniformivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformivEXT)
}
var _ = atom.Atom(&GlGetnUniformivKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformivKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformivKHR().
func (ϟa *GlGetnUniformivKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformivKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformivKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformivKHR)
}
var _ = atom.Atom(&GlGetnUniformuivKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformuivKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformuivKHR().
func (ϟa *GlGetnUniformuivKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformuivKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformuivKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformuivKHR)
}
var _ = atom.Atom(&GlInsertEventMarkerEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glInsertEventMarkerEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glInsertEventMarkerEXT().
func (ϟa *GlInsertEventMarkerEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_debug_marker); ϟerr != nil {
return ϟerr
}
if (ϟa.Length) > (GLsizei(int32(0))) {
ϟa.Marker.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Length), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(ϟa.Marker).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glInsertEventMarkerEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlInsertEventMarkerEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Marker.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlInsertEventMarkerEXT)
}
var _ = atom.Atom(&GlInterpolatePathsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glInterpolatePathsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glInterpolatePathsNV().
func (ϟa *GlInterpolatePathsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glInterpolatePathsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlInterpolatePathsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.ResultPath.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathA.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathB.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Weight.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlInterpolatePathsNV)
}
var _ = atom.Atom(&GlIsEnablediNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsEnablediNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsEnablediNV().
// Upon returning the glIsEnablediNV() return value will be stored on the stack.
func (ϟa *GlIsEnablediNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsEnabledi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsEnablediNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsEnablediNV() return value will be stored on the stack.
func (ϟa *GlIsEnablediNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsEnablediNV)
}
var _ = atom.Atom(&GlIsEnablediOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsEnablediOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsEnablediOES().
// Upon returning the glIsEnablediOES() return value will be stored on the stack.
func (ϟa *GlIsEnablediOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_buffers_indexed, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsEnabledi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Index)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsEnablediOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsEnablediOES() return value will be stored on the stack.
func (ϟa *GlIsEnablediOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsEnablediOES)
}
var _ = atom.Atom(&GlIsFenceNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsFenceNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsFenceNV().
// Upon returning the glIsFenceNV() return value will be stored on the stack.
func (ϟa *GlIsFenceNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsFenceNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsFenceNV() return value will be stored on the stack.
func (ϟa *GlIsFenceNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Fence.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsFenceNV)
}
var _ = atom.Atom(&GlIsImageHandleResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsImageHandleResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsImageHandleResidentNV().
// Upon returning the glIsImageHandleResidentNV() return value will be stored on the stack.
func (ϟa *GlIsImageHandleResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsImageHandleResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsImageHandleResidentNV() return value will be stored on the stack.
func (ϟa *GlIsImageHandleResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsImageHandleResidentNV)
}
var _ = atom.Atom(&GlIsPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsPathNV().
// Upon returning the glIsPathNV() return value will be stored on the stack.
func (ϟa *GlIsPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsPathNV() return value will be stored on the stack.
func (ϟa *GlIsPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsPathNV)
}
var _ = atom.Atom(&GlIsPointInFillPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsPointInFillPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsPointInFillPathNV().
// Upon returning the glIsPointInFillPathNV() return value will be stored on the stack.
func (ϟa *GlIsPointInFillPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsPointInFillPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsPointInFillPathNV() return value will be stored on the stack.
func (ϟa *GlIsPointInFillPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsPointInFillPathNV)
}
var _ = atom.Atom(&GlIsPointInStrokePathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsPointInStrokePathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsPointInStrokePathNV().
// Upon returning the glIsPointInStrokePathNV() return value will be stored on the stack.
func (ϟa *GlIsPointInStrokePathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsPointInStrokePathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsPointInStrokePathNV() return value will be stored on the stack.
func (ϟa *GlIsPointInStrokePathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsPointInStrokePathNV)
}
var _ = atom.Atom(&GlIsProgramPipelineEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsProgramPipelineEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsProgramPipelineEXT().
// Upon returning the glIsProgramPipelineEXT() return value will be stored on the stack.
func (ϟa *GlIsProgramPipelineEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsProgramPipelineEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsProgramPipelineEXT() return value will be stored on the stack.
func (ϟa *GlIsProgramPipelineEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsProgramPipelineEXT)
}
var _ = atom.Atom(&GlIsQueryEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsQueryEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsQueryEXT().
// Upon returning the glIsQueryEXT() return value will be stored on the stack.
func (ϟa *GlIsQueryEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension2(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query, ExtensionId_GL_EXT_occlusion_query_boolean); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Queries.Contains(ϟa.Query) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsQueryEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsQueryEXT() return value will be stored on the stack.
func (ϟa *GlIsQueryEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsQueryEXT)
}
var _ = atom.Atom(&GlIsSyncAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsSyncAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsSyncAPPLE().
// Upon returning the glIsSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlIsSyncAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsSyncAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsSyncAPPLE() return value will be stored on the stack.
func (ϟa *GlIsSyncAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsSyncAPPLE)
}
var _ = atom.Atom(&GlIsTextureHandleResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsTextureHandleResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsTextureHandleResidentNV().
// Upon returning the glIsTextureHandleResidentNV() return value will be stored on the stack.
func (ϟa *GlIsTextureHandleResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsTextureHandleResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsTextureHandleResidentNV() return value will be stored on the stack.
func (ϟa *GlIsTextureHandleResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsTextureHandleResidentNV)
}
var _ = atom.Atom(&GlIsVertexArrayOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsVertexArrayOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsVertexArrayOES().
// Upon returning the glIsVertexArrayOES() return value will be stored on the stack.
func (ϟa *GlIsVertexArrayOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_vertex_array_object); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Array)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsVertexArrayOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsVertexArrayOES() return value will be stored on the stack.
func (ϟa *GlIsVertexArrayOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsVertexArrayOES)
}
var _ = atom.Atom(&GlLabelObjectEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLabelObjectEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLabelObjectEXT().
func (ϟa *GlLabelObjectEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_debug_label); ϟerr != nil {
return ϟerr
}
str := func() (result string) {
switch (ϟa.Label) != (GLcharᶜᵖ{}) {
case true:
return func() (result string) {
switch (ϟa.Length) == (GLsizei(int32(0))) {
case true:
return strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(ϟa.Label).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
case false:
return string(gfxapi.CharToBytes(AsCharˢ(ϟa.Label.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Length), ϟs), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (ϟa.Length) == (GLsizei(int32(0))), ϟa))
return result
}
}()
case false:
return ""
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (ϟa.Label) != (GLcharᶜᵖ{}), ϟa))
return result
}
}()
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Type {
case GLenum_GL_TEXTURE:
if !(ctx.Instances.Textures.Contains(TextureId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Textures.Get(TextureId(ϟa.Object)).OnAccess(ϟs).Label = str
case GLenum_GL_FRAMEBUFFER:
if !(ctx.Instances.Framebuffers.Contains(FramebufferId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Framebuffers.Get(FramebufferId(ϟa.Object)).Label = str
case GLenum_GL_RENDERBUFFER:
if !(ctx.Instances.Renderbuffers.Contains(RenderbufferId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Renderbuffers.Get(RenderbufferId(ϟa.Object)).Label = str
case GLenum_GL_BUFFER_OBJECT_EXT:
if !(ctx.Instances.Buffers.Contains(BufferId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Buffers.Get(BufferId(ϟa.Object)).Label = str
case GLenum_GL_SHADER_OBJECT_EXT:
if !(ctx.Instances.Shaders.Contains(ShaderId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Shaders.Get(ShaderId(ϟa.Object)).OnAccess(ϟs).Label = str
case GLenum_GL_PROGRAM_OBJECT_EXT:
if !(ctx.Instances.Programs.Contains(ProgramId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Programs.Get(ProgramId(ϟa.Object)).OnAccess(ϟs).Label = str
case GLenum_GL_VERTEX_ARRAY_OBJECT_EXT:
if !(ctx.Instances.VertexArrays.Contains(VertexArrayId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.VertexArrays.Get(VertexArrayId(ϟa.Object)).Label = str
case GLenum_GL_QUERY_OBJECT_EXT:
if !(ctx.Instances.Queries.Contains(QueryId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Queries.Get(QueryId(ϟa.Object)).Label = str
case GLenum_GL_SAMPLER:
if !(ctx.Instances.Samplers.Contains(SamplerId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Samplers.Get(SamplerId(ϟa.Object)).Label = str
case GLenum_GL_TRANSFORM_FEEDBACK:
if !(ctx.Instances.TransformFeedbacks.Contains(TransformFeedbackId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.TransformFeedbacks.Get(TransformFeedbackId(ϟa.Object)).Label = str
case GLenum_GL_PROGRAM_PIPELINE_OBJECT_EXT:
if !(ctx.Instances.Pipelines.Contains(PipelineId(ϟa.Object))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.Instances.Pipelines.Get(PipelineId(ϟa.Object)).Label = str
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLabelObjectEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLabelObjectEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Object.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Label.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLabelObjectEXT)
}
var _ = atom.Atom(&GlMakeImageHandleNonResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMakeImageHandleNonResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMakeImageHandleNonResidentNV().
func (ϟa *GlMakeImageHandleNonResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMakeImageHandleNonResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMakeImageHandleNonResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMakeImageHandleNonResidentNV)
}
var _ = atom.Atom(&GlMakeImageHandleResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMakeImageHandleResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMakeImageHandleResidentNV().
func (ϟa *GlMakeImageHandleResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMakeImageHandleResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMakeImageHandleResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Call(funcInfoGlMakeImageHandleResidentNV)
}
var _ = atom.Atom(&GlMakeTextureHandleNonResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMakeTextureHandleNonResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMakeTextureHandleNonResidentNV().
func (ϟa *GlMakeTextureHandleNonResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMakeTextureHandleNonResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMakeTextureHandleNonResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMakeTextureHandleNonResidentNV)
}
var _ = atom.Atom(&GlMakeTextureHandleResidentNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMakeTextureHandleResidentNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMakeTextureHandleResidentNV().
func (ϟa *GlMakeTextureHandleResidentNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMakeTextureHandleResidentNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMakeTextureHandleResidentNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Handle.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMakeTextureHandleResidentNV)
}
var _ = atom.Atom(&GlMapBufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMapBufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMapBufferOES().
// Upon returning the glMapBufferOES() return value will be stored on the stack.
func (ϟa *GlMapBufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_mapbuffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ptr := ϟa.Result
if ϟerr := subMapBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Access, U8ᵖ(ptr)); ϟerr != nil {
return ϟerr
}
_ = ptr
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMapBufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glMapBufferOES() return value will be stored on the stack.
func (ϟa *GlMapBufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Call(funcInfoGlMapBufferOES)
}
var _ = atom.Atom(&GlMapBufferRangeEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMapBufferRangeEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMapBufferRangeEXT().
// Upon returning the glMapBufferRangeEXT() return value will be stored on the stack.
func (ϟa *GlMapBufferRangeEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_map_buffer_range); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ptr := ϟa.Result
if ϟerr := subMapBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Offset, ϟa.Length, ϟa.Access, U8ᵖ(ptr)); ϟerr != nil {
return ϟerr
}
_ = ptr
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMapBufferRangeEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glMapBufferRangeEXT() return value will be stored on the stack.
func (ϟa *GlMapBufferRangeEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Call(funcInfoGlMapBufferRangeEXT)
}
var _ = atom.Atom(&GlMatrixLoad3x2fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixLoad3x2fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixLoad3x2fNV().
func (ϟa *GlMatrixLoad3x2fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixLoad3x2fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixLoad3x2fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixLoad3x2fNV)
}
var _ = atom.Atom(&GlMatrixLoad3x3fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixLoad3x3fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixLoad3x3fNV().
func (ϟa *GlMatrixLoad3x3fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixLoad3x3fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixLoad3x3fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixLoad3x3fNV)
}
var _ = atom.Atom(&GlMatrixLoadTranspose3x3fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixLoadTranspose3x3fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixLoadTranspose3x3fNV().
func (ϟa *GlMatrixLoadTranspose3x3fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixLoadTranspose3x3fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixLoadTranspose3x3fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixLoadTranspose3x3fNV)
}
var _ = atom.Atom(&GlMatrixMult3x2fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixMult3x2fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixMult3x2fNV().
func (ϟa *GlMatrixMult3x2fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixMult3x2fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixMult3x2fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixMult3x2fNV)
}
var _ = atom.Atom(&GlMatrixMult3x3fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixMult3x3fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixMult3x3fNV().
func (ϟa *GlMatrixMult3x3fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixMult3x3fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixMult3x3fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixMult3x3fNV)
}
var _ = atom.Atom(&GlMatrixMultTranspose3x3fNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixMultTranspose3x3fNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixMultTranspose3x3fNV().
func (ϟa *GlMatrixMultTranspose3x3fNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixMultTranspose3x3fNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixMultTranspose3x3fNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.MatrixMode))
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixMultTranspose3x3fNV)
}
var _ = atom.Atom(&GlMultiDrawArraysEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawArraysEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawArraysEXT().
func (ϟa *GlMultiDrawArraysEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multi_draw_arrays); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawArraysEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawArraysEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawArraysEXT)
}
var _ = atom.Atom(&GlMultiDrawArraysIndirectEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawArraysIndirectEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawArraysIndirectEXT().
func (ϟa *GlMultiDrawArraysIndirectEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multi_draw_indirect); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawArraysIndirectEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawArraysIndirectEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Indirect.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Drawcount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawArraysIndirectEXT)
}
var _ = atom.Atom(&GlMultiDrawElementsBaseVertexEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawElementsBaseVertexEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawElementsBaseVertexEXT().
func (ϟa *GlMultiDrawElementsBaseVertexEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawElementsBaseVertexEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawElementsBaseVertexEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawElementsBaseVertexEXT)
}
var _ = atom.Atom(&GlMultiDrawElementsBaseVertexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawElementsBaseVertexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawElementsBaseVertexOES().
func (ϟa *GlMultiDrawElementsBaseVertexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_elements_base_vertex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawElementsBaseVertexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawElementsBaseVertexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Basevertex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawElementsBaseVertexOES)
}
var _ = atom.Atom(&GlMultiDrawElementsEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawElementsEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawElementsEXT().
func (ϟa *GlMultiDrawElementsEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multi_draw_arrays); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawElementsEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawElementsEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indices.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Primcount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawElementsEXT)
}
var _ = atom.Atom(&GlMultiDrawElementsIndirectEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiDrawElementsIndirectEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiDrawElementsIndirectEXT().
func (ϟa *GlMultiDrawElementsIndirectEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multi_draw_indirect); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiDrawElementsIndirectEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiDrawElementsIndirectEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Indirect.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Drawcount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiDrawElementsIndirectEXT)
}
var _ = atom.Atom(&GlNamedFramebufferSampleLocationsfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNamedFramebufferSampleLocationsfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNamedFramebufferSampleLocationsfvNV().
func (ϟa *GlNamedFramebufferSampleLocationsfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_sample_locations); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNamedFramebufferSampleLocationsfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNamedFramebufferSampleLocationsfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Framebuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Start.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNamedFramebufferSampleLocationsfvNV)
}
var _ = atom.Atom(&GlPatchParameteriOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPatchParameteriOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPatchParameteriOES().
func (ϟa *GlPatchParameteriOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_tessellation_shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subPatchParameteri(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPatchParameteriOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPatchParameteriOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPatchParameteriOES)
}
var _ = atom.Atom(&GlPathCommandsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathCommandsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathCommandsNV().
func (ϟa *GlPathCommandsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathCommandsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathCommandsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCommands.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Commands.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCoords.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoordType))
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathCommandsNV)
}
var _ = atom.Atom(&GlPathCoordsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathCoordsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathCoordsNV().
func (ϟa *GlPathCoordsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathCoordsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathCoordsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCoords.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoordType))
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathCoordsNV)
}
var _ = atom.Atom(&GlPathCoverDepthFuncNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathCoverDepthFuncNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathCoverDepthFuncNV().
func (ϟa *GlPathCoverDepthFuncNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathCoverDepthFuncNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathCoverDepthFuncNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Call(funcInfoGlPathCoverDepthFuncNV)
}
var _ = atom.Atom(&GlPathDashArrayNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathDashArrayNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathDashArrayNV().
func (ϟa *GlPathDashArrayNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathDashArrayNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathDashArrayNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DashCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DashArray.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathDashArrayNV)
}
var _ = atom.Atom(&GlPathGlyphIndexArrayNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathGlyphIndexArrayNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathGlyphIndexArrayNV().
// Upon returning the glPathGlyphIndexArrayNV() return value will be stored on the stack.
func (ϟa *GlPathGlyphIndexArrayNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathGlyphIndexArrayNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glPathGlyphIndexArrayNV() return value will be stored on the stack.
func (ϟa *GlPathGlyphIndexArrayNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.FirstPathName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontTarget))
ϟb.Push(ϟa.FontName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontStyle))
ϟb.Push(ϟa.FirstGlyphIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumGlyphs.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathParameterTemplate.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.EmScale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathGlyphIndexArrayNV)
}
var _ = atom.Atom(&GlPathGlyphIndexRangeNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathGlyphIndexRangeNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathGlyphIndexRangeNV().
// Upon returning the glPathGlyphIndexRangeNV() return value will be stored on the stack.
func (ϟa *GlPathGlyphIndexRangeNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathGlyphIndexRangeNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glPathGlyphIndexRangeNV() return value will be stored on the stack.
func (ϟa *GlPathGlyphIndexRangeNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.FontTarget))
ϟb.Push(ϟa.FontName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontStyle))
ϟb.Push(ϟa.PathParameterTemplate.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.EmScale.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseAndCount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathGlyphIndexRangeNV)
}
var _ = atom.Atom(&GlPathGlyphRangeNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathGlyphRangeNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathGlyphRangeNV().
func (ϟa *GlPathGlyphRangeNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathGlyphRangeNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathGlyphRangeNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.FirstPathName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontTarget))
ϟb.Push(ϟa.FontName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontStyle))
ϟb.Push(ϟa.FirstGlyph.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumGlyphs.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.HandleMissingGlyphs))
ϟb.Push(ϟa.PathParameterTemplate.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.EmScale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathGlyphRangeNV)
}
var _ = atom.Atom(&GlPathGlyphsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathGlyphsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathGlyphsNV().
func (ϟa *GlPathGlyphsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathGlyphsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathGlyphsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.FirstPathName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontTarget))
ϟb.Push(ϟa.FontName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontStyle))
ϟb.Push(ϟa.NumGlyphs.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Charcodes.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.HandleMissingGlyphs))
ϟb.Push(ϟa.PathParameterTemplate.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.EmScale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathGlyphsNV)
}
var _ = atom.Atom(&GlPathMemoryGlyphIndexArrayNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathMemoryGlyphIndexArrayNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathMemoryGlyphIndexArrayNV().
// Upon returning the glPathMemoryGlyphIndexArrayNV() return value will be stored on the stack.
func (ϟa *GlPathMemoryGlyphIndexArrayNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathMemoryGlyphIndexArrayNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glPathMemoryGlyphIndexArrayNV() return value will be stored on the stack.
func (ϟa *GlPathMemoryGlyphIndexArrayNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.FirstPathName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FontTarget))
ϟb.Push(ϟa.FontSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.FontData.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.FaceIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.FirstGlyphIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumGlyphs.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathParameterTemplate.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.EmScale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathMemoryGlyphIndexArrayNV)
}
var _ = atom.Atom(&GlPathParameterfNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathParameterfNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathParameterfNV().
func (ϟa *GlPathParameterfNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathParameterfNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathParameterfNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathParameterfNV)
}
var _ = atom.Atom(&GlPathParameterfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathParameterfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathParameterfvNV().
func (ϟa *GlPathParameterfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathParameterfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathParameterfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathParameterfvNV)
}
var _ = atom.Atom(&GlPathParameteriNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathParameteriNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathParameteriNV().
func (ϟa *GlPathParameteriNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathParameteriNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathParameteriNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathParameteriNV)
}
var _ = atom.Atom(&GlPathParameterivNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathParameterivNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathParameterivNV().
func (ϟa *GlPathParameterivNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathParameterivNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathParameterivNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathParameterivNV)
}
var _ = atom.Atom(&GlPathStencilDepthOffsetNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathStencilDepthOffsetNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathStencilDepthOffsetNV().
func (ϟa *GlPathStencilDepthOffsetNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathStencilDepthOffsetNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathStencilDepthOffsetNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Factor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Units.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathStencilDepthOffsetNV)
}
var _ = atom.Atom(&GlPathStencilFuncNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathStencilFuncNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathStencilFuncNV().
func (ϟa *GlPathStencilFuncNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathStencilFuncNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathStencilFuncNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathStencilFuncNV)
}
var _ = atom.Atom(&GlPathStringNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathStringNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathStringNV().
func (ϟa *GlPathStringNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathStringNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathStringNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathString.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathStringNV)
}
var _ = atom.Atom(&GlPathSubCommandsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathSubCommandsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathSubCommandsNV().
func (ϟa *GlPathSubCommandsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathSubCommandsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathSubCommandsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CommandStart.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CommandsToDelete.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCommands.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Commands.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCoords.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoordType))
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathSubCommandsNV)
}
var _ = atom.Atom(&GlPathSubCoordsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPathSubCoordsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPathSubCoordsNV().
func (ϟa *GlPathSubCoordsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPathSubCoordsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPathSubCoordsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CoordStart.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCoords.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoordType))
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPathSubCoordsNV)
}
var _ = atom.Atom(&GlPointAlongPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointAlongPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointAlongPathNV().
// Upon returning the glPointAlongPathNV() return value will be stored on the stack.
func (ϟa *GlPointAlongPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointAlongPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glPointAlongPathNV() return value will be stored on the stack.
func (ϟa *GlPointAlongPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.StartSegment.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumSegments.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Distance.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.TangentX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.TangentY.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointAlongPathNV)
}
var _ = atom.Atom(&GlPolygonModeNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPolygonModeNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPolygonModeNV().
func (ϟa *GlPolygonModeNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_polygon_mode); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPolygonModeNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPolygonModeNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlPolygonModeNV)
}
var _ = atom.Atom(&GlPopGroupMarkerEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPopGroupMarkerEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPopGroupMarkerEXT().
func (ϟa *GlPopGroupMarkerEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_debug_marker); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPopGroupMarkerEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPopGroupMarkerEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPopGroupMarkerEXT)
}
var _ = atom.Atom(&GlPrimitiveBoundingBoxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPrimitiveBoundingBoxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPrimitiveBoundingBoxOES().
func (ϟa *GlPrimitiveBoundingBoxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_primitive_bounding_box); ϟerr != nil {
return ϟerr
}
if ϟerr := subPrimitiveBoundingBox(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.MinX, ϟa.MinY, ϟa.MinZ, ϟa.MinW, ϟa.MaxX, ϟa.MaxY, ϟa.MaxZ, ϟa.MaxW); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPrimitiveBoundingBoxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPrimitiveBoundingBoxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.MinX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MinW.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.MaxW.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPrimitiveBoundingBoxOES)
}
var _ = atom.Atom(&GlProgramBinaryOES{}) // interface compliance check
func (ϟa *GlProgramBinaryOES) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_get_program_binary); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subProgramBinary(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.BinaryFormat, ϟa.Binary, GLsizei(ϟa.BinarySize)); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramBinaryOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramBinaryOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.BinaryFormat))
ϟb.Push(ϟa.Binary.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BinarySize.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramBinaryOES)
}
var _ = atom.Atom(&GlProgramParameteriEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramParameteriEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramParameteriEXT().
func (ϟa *GlProgramParameteriEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramParameteri(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Pname, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramParameteriEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramParameteriEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramParameteriEXT)
}
var _ = atom.Atom(&GlProgramPathFragmentInputGenNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramPathFragmentInputGenNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramPathFragmentInputGenNV().
func (ϟa *GlProgramPathFragmentInputGenNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramPathFragmentInputGenNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramPathFragmentInputGenNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.GenMode))
ϟb.Push(ϟa.Components.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Coeffs.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramPathFragmentInputGenNV)
}
var _ = atom.Atom(&GlProgramUniform1fEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1fEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1fEXT().
func (ϟa *GlProgramUniform1fEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1fEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1fEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1fEXT)
}
var _ = atom.Atom(&GlProgramUniform1fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1fvEXT().
func (ϟa *GlProgramUniform1fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1fvEXT)
}
var _ = atom.Atom(&GlProgramUniform1iEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1iEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1iEXT().
func (ϟa *GlProgramUniform1iEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1iEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1iEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1iEXT)
}
var _ = atom.Atom(&GlProgramUniform1ivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1ivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1ivEXT().
func (ϟa *GlProgramUniform1ivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1ivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1ivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1ivEXT)
}
var _ = atom.Atom(&GlProgramUniform1uiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1uiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1uiEXT().
func (ϟa *GlProgramUniform1uiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1uiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1uiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1uiEXT)
}
var _ = atom.Atom(&GlProgramUniform1uivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1uivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1uivEXT().
func (ϟa *GlProgramUniform1uivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1uivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1uivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1uivEXT)
}
var _ = atom.Atom(&GlProgramUniform2fEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2fEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2fEXT().
func (ϟa *GlProgramUniform2fEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2fEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2fEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2fEXT)
}
var _ = atom.Atom(&GlProgramUniform2fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2fvEXT().
func (ϟa *GlProgramUniform2fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2fvEXT)
}
var _ = atom.Atom(&GlProgramUniform2iEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2iEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2iEXT().
func (ϟa *GlProgramUniform2iEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2iEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2iEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2iEXT)
}
var _ = atom.Atom(&GlProgramUniform2ivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2ivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2ivEXT().
func (ϟa *GlProgramUniform2ivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2ivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2ivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2ivEXT)
}
var _ = atom.Atom(&GlProgramUniform2uiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2uiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2uiEXT().
func (ϟa *GlProgramUniform2uiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2uiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2uiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2uiEXT)
}
var _ = atom.Atom(&GlProgramUniform2uivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2uivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2uivEXT().
func (ϟa *GlProgramUniform2uivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2uivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2uivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2uivEXT)
}
var _ = atom.Atom(&GlProgramUniform3fEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3fEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3fEXT().
func (ϟa *GlProgramUniform3fEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3fEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3fEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3fEXT)
}
var _ = atom.Atom(&GlProgramUniform3fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3fvEXT().
func (ϟa *GlProgramUniform3fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3fvEXT)
}
var _ = atom.Atom(&GlProgramUniform3iEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3iEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3iEXT().
func (ϟa *GlProgramUniform3iEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3iEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3iEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3iEXT)
}
var _ = atom.Atom(&GlProgramUniform3ivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3ivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3ivEXT().
func (ϟa *GlProgramUniform3ivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3ivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3ivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3ivEXT)
}
var _ = atom.Atom(&GlProgramUniform3uiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3uiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3uiEXT().
func (ϟa *GlProgramUniform3uiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3uiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3uiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3uiEXT)
}
var _ = atom.Atom(&GlProgramUniform3uivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3uivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3uivEXT().
func (ϟa *GlProgramUniform3uivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3uivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3uivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3uivEXT)
}
var _ = atom.Atom(&GlProgramUniform4fEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4fEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4fEXT().
func (ϟa *GlProgramUniform4fEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2, ϟa.V3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4fEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4fEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4fEXT)
}
var _ = atom.Atom(&GlProgramUniform4fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4fvEXT().
func (ϟa *GlProgramUniform4fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4fvEXT)
}
var _ = atom.Atom(&GlProgramUniform4iEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4iEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4iEXT().
func (ϟa *GlProgramUniform4iEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2, ϟa.V3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4iEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4iEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4iEXT)
}
var _ = atom.Atom(&GlProgramUniform4ivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4ivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4ivEXT().
func (ϟa *GlProgramUniform4ivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4ivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4ivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4ivEXT)
}
var _ = atom.Atom(&GlProgramUniform4uiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4uiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4uiEXT().
func (ϟa *GlProgramUniform4uiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.V0, ϟa.V1, ϟa.V2, ϟa.V3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4uiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4uiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4uiEXT)
}
var _ = atom.Atom(&GlProgramUniform4uivEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4uivEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4uivEXT().
func (ϟa *GlProgramUniform4uivEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4uivEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4uivEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4uivEXT)
}
var _ = atom.Atom(&GlProgramUniformHandleui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformHandleui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformHandleui64NV().
func (ϟa *GlProgramUniformHandleui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformHandleui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformHandleui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformHandleui64NV)
}
var _ = atom.Atom(&GlProgramUniformHandleui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformHandleui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformHandleui64vNV().
func (ϟa *GlProgramUniformHandleui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformHandleui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformHandleui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformHandleui64vNV)
}
var _ = atom.Atom(&GlProgramUniformMatrix2fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2fvEXT().
func (ϟa *GlProgramUniformMatrix2fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix2x3fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2x3fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2x3fvEXT().
func (ϟa *GlProgramUniformMatrix2x3fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2x3fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2x3fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2x3fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix2x4fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2x4fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2x4fvEXT().
func (ϟa *GlProgramUniformMatrix2x4fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2x4fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2x4fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2x4fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix3fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3fvEXT().
func (ϟa *GlProgramUniformMatrix3fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix3x2fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3x2fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3x2fvEXT().
func (ϟa *GlProgramUniformMatrix3x2fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3x2fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3x2fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3x2fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix3x4fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3x4fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3x4fvEXT().
func (ϟa *GlProgramUniformMatrix3x4fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3x4fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3x4fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3x4fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix4fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4fvEXT().
func (ϟa *GlProgramUniformMatrix4fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix4x2fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4x2fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4x2fvEXT().
func (ϟa *GlProgramUniformMatrix4x2fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4x2fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4x2fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4x2fvEXT)
}
var _ = atom.Atom(&GlProgramUniformMatrix4x3fvEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4x3fvEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4x3fvEXT().
func (ϟa *GlProgramUniformMatrix4x3fvEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4x3fvEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4x3fvEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4x3fvEXT)
}
var _ = atom.Atom(&GlPushGroupMarkerEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPushGroupMarkerEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPushGroupMarkerEXT().
func (ϟa *GlPushGroupMarkerEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_debug_marker); ϟerr != nil {
return ϟerr
}
if (ϟa.Length) > (GLsizei(int32(0))) {
ϟa.Marker.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Length), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(ϟa.Marker).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPushGroupMarkerEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPushGroupMarkerEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Marker.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPushGroupMarkerEXT)
}
var _ = atom.Atom(&GlQueryCounterEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glQueryCounterEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glQueryCounterEXT().
func (ϟa *GlQueryCounterEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_disjoint_timer_query); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glQueryCounterEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlQueryCounterEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlQueryCounterEXT)
}
var _ = atom.Atom(&GlRasterSamplesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRasterSamplesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRasterSamplesEXT().
func (ϟa *GlRasterSamplesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension3(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_raster_multisample, ExtensionId_GL_EXT_texture_filter_minmax, ExtensionId_GL_NV_framebuffer_mixed_samples); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRasterSamplesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRasterSamplesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fixedsamplelocations.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRasterSamplesEXT)
}
var _ = atom.Atom(&GlReadBufferIndexedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadBufferIndexedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadBufferIndexedEXT().
func (ϟa *GlReadBufferIndexedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multiview_draw_buffers); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadBufferIndexedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadBufferIndexedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Src))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlReadBufferIndexedEXT)
}
var _ = atom.Atom(&GlReadBufferNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadBufferNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadBufferNV().
func (ϟa *GlReadBufferNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_read_buffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadBufferNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadBufferNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlReadBufferNV)
}
var _ = atom.Atom(&GlReadnPixelsEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadnPixelsEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadnPixelsEXT().
func (ϟa *GlReadnPixelsEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subReadnPixels(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.X, ϟa.Y, ϟa.Width, ϟa.Height, ϟa.Format, ϟa.Type, ϟa.BufSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadnPixelsEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadnPixelsEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlReadnPixelsEXT)
}
var _ = atom.Atom(&GlReadnPixelsKHR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadnPixelsKHR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadnPixelsKHR().
func (ϟa *GlReadnPixelsKHR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_KHR_robustness); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subReadnPixels(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.X, ϟa.Y, ϟa.Width, ϟa.Height, ϟa.Format, ϟa.Type, ϟa.BufSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadnPixelsKHR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadnPixelsKHR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlReadnPixelsKHR)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisampleANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisampleANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisampleANGLE().
func (ϟa *GlRenderbufferStorageMultisampleANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_framebuffer_multisample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisampleANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisampleANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisampleANGLE)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisampleAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisampleAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisampleAPPLE().
func (ϟa *GlRenderbufferStorageMultisampleAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_framebuffer_multisample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisampleAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisampleAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisampleAPPLE)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisampleEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisampleEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisampleEXT().
func (ϟa *GlRenderbufferStorageMultisampleEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_multisampled_render_to_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subRenderbufferStorageMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Samples, ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisampleEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisampleEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisampleEXT)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisampleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisampleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisampleIMG().
func (ϟa *GlRenderbufferStorageMultisampleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_multisampled_render_to_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisampleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisampleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisampleIMG)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisampleNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisampleNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisampleNV().
func (ϟa *GlRenderbufferStorageMultisampleNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_framebuffer_multisample); ϟerr != nil {
return ϟerr
}
if ϟerr := subRenderbufferStorageMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Samples, ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisampleNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisampleNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisampleNV)
}
var _ = atom.Atom(&GlResolveDepthValuesNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glResolveDepthValuesNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glResolveDepthValuesNV().
func (ϟa *GlResolveDepthValuesNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_sample_locations); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glResolveDepthValuesNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlResolveDepthValuesNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlResolveDepthValuesNV)
}
var _ = atom.Atom(&GlResolveMultisampleFramebufferAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glResolveMultisampleFramebufferAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glResolveMultisampleFramebufferAPPLE().
func (ϟa *GlResolveMultisampleFramebufferAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_framebuffer_multisample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glResolveMultisampleFramebufferAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlResolveMultisampleFramebufferAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlResolveMultisampleFramebufferAPPLE)
}
var _ = atom.Atom(&GlSamplerParameterIivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIivOES().
func (ϟa *GlSamplerParameterIivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIivOES)
}
var _ = atom.Atom(&GlSamplerParameterIuivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIuivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIuivOES().
func (ϟa *GlSamplerParameterIuivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIuivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIuivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIuivOES)
}
var _ = atom.Atom(&GlScissorArrayvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorArrayvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorArrayvNV().
func (ϟa *GlScissorArrayvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorArrayvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorArrayvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorArrayvNV)
}
var _ = atom.Atom(&GlScissorIndexedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorIndexedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorIndexedNV().
func (ϟa *GlScissorIndexedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorIndexedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorIndexedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Left.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Bottom.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorIndexedNV)
}
var _ = atom.Atom(&GlScissorIndexedvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorIndexedvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorIndexedvNV().
func (ϟa *GlScissorIndexedvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorIndexedvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorIndexedvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorIndexedvNV)
}
var _ = atom.Atom(&GlSelectPerfMonitorCountersAMD{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSelectPerfMonitorCountersAMD.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSelectPerfMonitorCountersAMD().
func (ϟa *GlSelectPerfMonitorCountersAMD) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_performance_monitor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSelectPerfMonitorCountersAMD().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSelectPerfMonitorCountersAMD) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Monitor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Enable.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Group.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumCounters.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.CounterList.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSelectPerfMonitorCountersAMD)
}
var _ = atom.Atom(&GlSetFenceNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSetFenceNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSetFenceNV().
func (ϟa *GlSetFenceNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSetFenceNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSetFenceNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Fence.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Condition))
ϟb.Call(funcInfoGlSetFenceNV)
}
var _ = atom.Atom(&GlStartTilingQCOM{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStartTilingQCOM.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStartTilingQCOM().
func (ϟa *GlStartTilingQCOM) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_QCOM_tiled_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStartTilingQCOM().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStartTilingQCOM) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PreserveMask))
ϟb.Call(funcInfoGlStartTilingQCOM)
}
var _ = atom.Atom(&GlStencilFillPathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilFillPathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilFillPathInstancedNV().
func (ϟa *GlStencilFillPathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilFillPathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilFillPathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FillMode))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilFillPathInstancedNV)
}
var _ = atom.Atom(&GlStencilFillPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilFillPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilFillPathNV().
func (ϟa *GlStencilFillPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilFillPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilFillPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FillMode))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilFillPathNV)
}
var _ = atom.Atom(&GlStencilStrokePathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilStrokePathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilStrokePathInstancedNV().
func (ϟa *GlStencilStrokePathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilStrokePathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilStrokePathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Reference.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilStrokePathInstancedNV)
}
var _ = atom.Atom(&GlStencilStrokePathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilStrokePathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilStrokePathNV().
func (ϟa *GlStencilStrokePathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilStrokePathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilStrokePathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Reference.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilStrokePathNV)
}
var _ = atom.Atom(&GlStencilThenCoverFillPathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilThenCoverFillPathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilThenCoverFillPathInstancedNV().
func (ϟa *GlStencilThenCoverFillPathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilThenCoverFillPathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilThenCoverFillPathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FillMode))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilThenCoverFillPathInstancedNV)
}
var _ = atom.Atom(&GlStencilThenCoverFillPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilThenCoverFillPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilThenCoverFillPathNV().
func (ϟa *GlStencilThenCoverFillPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilThenCoverFillPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilThenCoverFillPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.FillMode))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Call(funcInfoGlStencilThenCoverFillPathNV)
}
var _ = atom.Atom(&GlStencilThenCoverStrokePathInstancedNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilThenCoverStrokePathInstancedNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilThenCoverStrokePathInstancedNV().
func (ϟa *GlStencilThenCoverStrokePathInstancedNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilThenCoverStrokePathInstancedNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilThenCoverStrokePathInstancedNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.PathNameType))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PathBase.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Reference.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilThenCoverStrokePathInstancedNV)
}
var _ = atom.Atom(&GlStencilThenCoverStrokePathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilThenCoverStrokePathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilThenCoverStrokePathNV().
func (ϟa *GlStencilThenCoverStrokePathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilThenCoverStrokePathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilThenCoverStrokePathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Path.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Reference.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.CoverMode))
ϟb.Call(funcInfoGlStencilThenCoverStrokePathNV)
}
var _ = atom.Atom(&GlSubpixelPrecisionBiasNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSubpixelPrecisionBiasNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSubpixelPrecisionBiasNV().
func (ϟa *GlSubpixelPrecisionBiasNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_conservative_raster); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSubpixelPrecisionBiasNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSubpixelPrecisionBiasNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Xbits.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ybits.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSubpixelPrecisionBiasNV)
}
var _ = atom.Atom(&GlTestFenceNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTestFenceNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTestFenceNV().
// Upon returning the glTestFenceNV() return value will be stored on the stack.
func (ϟa *GlTestFenceNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_fence); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTestFenceNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glTestFenceNV() return value will be stored on the stack.
func (ϟa *GlTestFenceNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Fence.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTestFenceNV)
}
var _ = atom.Atom(&GlTexBufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBufferOES().
func (ϟa *GlTexBufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlTexBufferOES)
}
var _ = atom.Atom(&GlTexBufferRangeOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBufferRangeOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBufferRangeOES().
func (ϟa *GlTexBufferRangeOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_buffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer, ϟa.Offset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBufferRangeOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBufferRangeOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexBufferRangeOES)
}
var _ = atom.Atom(&GlTexImage3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexImage3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexImage3DOES().
func (ϟa *GlTexImage3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, GLint(ϟa.Internalformat), ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Border, ϟa.Format, ϟa.Type, ϟa.Pixels); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexImage3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexImage3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Pixels.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexImage3DOES)
}
var _ = atom.Atom(&GlTexPageCommitmentEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexPageCommitmentEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexPageCommitmentEXT().
func (ϟa *GlTexPageCommitmentEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_sparse_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexPageCommitmentEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexPageCommitmentEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Commit.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexPageCommitmentEXT)
}
var _ = atom.Atom(&GlTexParameterIivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIivOES().
func (ϟa *GlTexParameterIivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIivOES)
}
var _ = atom.Atom(&GlTexParameterIuivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIuivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIuivOES().
func (ϟa *GlTexParameterIuivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_border_clamp); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIuivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIuivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIuivOES)
}
var _ = atom.Atom(&GlTexStorage1DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage1DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage1DEXT().
func (ϟa *GlTexStorage1DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage1DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage1DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage1DEXT)
}
var _ = atom.Atom(&GlTexStorage2DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage2DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage2DEXT().
func (ϟa *GlTexStorage2DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage2D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Levels, ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage2DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage2DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage2DEXT)
}
var _ = atom.Atom(&GlTexStorage3DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage3DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage3DEXT().
func (ϟa *GlTexStorage3DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Levels, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage3DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage3DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage3DEXT)
}
var _ = atom.Atom(&GlTexSubImage3DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexSubImage3DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexSubImage3DOES().
func (ϟa *GlTexSubImage3DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_3D); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Format, ϟa.Type, ϟa.Pixels); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexSubImage3DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexSubImage3DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Pixels.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexSubImage3DOES)
}
var _ = atom.Atom(&GlTextureStorage1DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTextureStorage1DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTextureStorage1DEXT().
func (ϟa *GlTextureStorage1DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTextureStorage1DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTextureStorage1DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTextureStorage1DEXT)
}
var _ = atom.Atom(&GlTextureStorage2DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTextureStorage2DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTextureStorage2DEXT().
func (ϟa *GlTextureStorage2DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTextureStorage2DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTextureStorage2DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTextureStorage2DEXT)
}
var _ = atom.Atom(&GlTextureStorage3DEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTextureStorage3DEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTextureStorage3DEXT().
func (ϟa *GlTextureStorage3DEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_storage); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTextureStorage3DEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTextureStorage3DEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTextureStorage3DEXT)
}
var _ = atom.Atom(&GlTextureViewEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTextureViewEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTextureViewEXT().
func (ϟa *GlTextureViewEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_view); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTextureViewEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTextureViewEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Origtexture.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Minlevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Numlevels.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Minlayer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Numlayers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTextureViewEXT)
}
var _ = atom.Atom(&GlTextureViewOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTextureViewOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTextureViewOES().
func (ϟa *GlTextureViewOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_view); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTextureViewOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTextureViewOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Origtexture.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Minlevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Numlevels.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Minlayer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Numlayers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTextureViewOES)
}
var _ = atom.Atom(&GlTransformPathNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTransformPathNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTransformPathNV().
func (ϟa *GlTransformPathNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTransformPathNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTransformPathNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.ResultPath.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcPath.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.TransformType))
ϟb.Push(ϟa.TransformValues.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTransformPathNV)
}
var _ = atom.Atom(&GlUniformHandleui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformHandleui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformHandleui64NV().
func (ϟa *GlUniformHandleui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformHandleui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformHandleui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformHandleui64NV)
}
var _ = atom.Atom(&GlUniformHandleui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformHandleui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformHandleui64vNV().
func (ϟa *GlUniformHandleui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformHandleui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformHandleui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformHandleui64vNV)
}
var _ = atom.Atom(&GlUniformMatrix2x3fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix2x3fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix2x3fvNV().
func (ϟa *GlUniformMatrix2x3fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix2x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix2x3fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix2x3fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix2x3fvNV)
}
var _ = atom.Atom(&GlUniformMatrix2x4fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix2x4fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix2x4fvNV().
func (ϟa *GlUniformMatrix2x4fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix2x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix2x4fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix2x4fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix2x4fvNV)
}
var _ = atom.Atom(&GlUniformMatrix3x2fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix3x2fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix3x2fvNV().
func (ϟa *GlUniformMatrix3x2fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix3x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix3x2fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix3x2fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix3x2fvNV)
}
var _ = atom.Atom(&GlUniformMatrix3x4fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix3x4fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix3x4fvNV().
func (ϟa *GlUniformMatrix3x4fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix3x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix3x4fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix3x4fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix3x4fvNV)
}
var _ = atom.Atom(&GlUniformMatrix4x2fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix4x2fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix4x2fvNV().
func (ϟa *GlUniformMatrix4x2fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix4x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix4x2fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix4x2fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix4x2fvNV)
}
var _ = atom.Atom(&GlUniformMatrix4x3fvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix4x3fvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix4x3fvNV().
func (ϟa *GlUniformMatrix4x3fvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_non_square_matrices); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix4x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix4x3fvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix4x3fvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix4x3fvNV)
}
var _ = atom.Atom(&GlUnmapBufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUnmapBufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUnmapBufferOES().
// Upon returning the glUnmapBufferOES() return value will be stored on the stack.
func (ϟa *GlUnmapBufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_mapbuffer); ϟerr != nil {
return ϟerr
}
if ϟerr := subUnmapBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUnmapBufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glUnmapBufferOES() return value will be stored on the stack.
func (ϟa *GlUnmapBufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlUnmapBufferOES)
}
var _ = atom.Atom(&GlUseProgramStagesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUseProgramStagesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUseProgramStagesEXT().
func (ϟa *GlUseProgramStagesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUseProgramStagesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUseProgramStagesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Stages))
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlUseProgramStagesEXT)
}
var _ = atom.Atom(&GlValidateProgramPipelineEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glValidateProgramPipelineEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glValidateProgramPipelineEXT().
func (ϟa *GlValidateProgramPipelineEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_separate_shader_objects); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glValidateProgramPipelineEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlValidateProgramPipelineEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlValidateProgramPipelineEXT)
}
var _ = atom.Atom(&GlVertexAttribDivisorANGLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribDivisorANGLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribDivisorANGLE().
func (ϟa *GlVertexAttribDivisorANGLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_ANGLE_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribDivisor(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.Divisor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribDivisorANGLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribDivisorANGLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Divisor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribDivisorANGLE)
}
var _ = atom.Atom(&GlVertexAttribDivisorEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribDivisorEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribDivisorEXT().
func (ϟa *GlVertexAttribDivisorEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribDivisor(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.Divisor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribDivisorEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribDivisorEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Divisor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribDivisorEXT)
}
var _ = atom.Atom(&GlVertexAttribDivisorNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribDivisorNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribDivisorNV().
func (ϟa *GlVertexAttribDivisorNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_instanced_arrays); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribDivisor(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.Divisor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribDivisorNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribDivisorNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Divisor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribDivisorNV)
}
var _ = atom.Atom(&GlViewportArrayvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportArrayvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportArrayvNV().
func (ϟa *GlViewportArrayvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportArrayvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportArrayvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportArrayvNV)
}
var _ = atom.Atom(&GlViewportIndexedfNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportIndexedfNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportIndexedfNV().
func (ϟa *GlViewportIndexedfNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportIndexedfNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportIndexedfNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.H.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportIndexedfNV)
}
var _ = atom.Atom(&GlViewportIndexedfvNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportIndexedfvNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportIndexedfvNV().
func (ϟa *GlViewportIndexedfvNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportIndexedfvNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportIndexedfvNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportIndexedfvNV)
}
var _ = atom.Atom(&GlWaitSyncAPPLE{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWaitSyncAPPLE.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWaitSyncAPPLE().
func (ϟa *GlWaitSyncAPPLE) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_APPLE_sync); ϟerr != nil {
return ϟerr
}
if ϟerr := subWaitSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.Flag, ϟa.Timeout); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWaitSyncAPPLE().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWaitSyncAPPLE) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Flag))
ϟb.Push(ϟa.Timeout.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWaitSyncAPPLE)
}
var _ = atom.Atom(&GlWeightPathsNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWeightPathsNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWeightPathsNV().
func (ϟa *GlWeightPathsNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_path_rendering); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWeightPathsNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWeightPathsNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.ResultPath.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumPaths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Paths.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Weights.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWeightPathsNV)
}
var _ = atom.Atom(&GlClearPixelLocalStorageuiEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearPixelLocalStorageuiEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearPixelLocalStorageuiEXT().
func (ϟa *GlClearPixelLocalStorageuiEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_shader_pixel_local_storage2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearPixelLocalStorageuiEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearPixelLocalStorageuiEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearPixelLocalStorageuiEXT)
}
var _ = atom.Atom(&GlClearTexImageEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearTexImageEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearTexImageEXT().
func (ϟa *GlClearTexImageEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_clear_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearTexImageEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearTexImageEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearTexImageEXT)
}
var _ = atom.Atom(&GlClearTexSubImageEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearTexSubImageEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearTexSubImageEXT().
func (ϟa *GlClearTexSubImageEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_clear_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearTexSubImageEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearTexSubImageEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearTexSubImageEXT)
}
var _ = atom.Atom(&GlConservativeRasterParameteriNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glConservativeRasterParameteriNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glConservativeRasterParameteriNV().
func (ϟa *GlConservativeRasterParameteriNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_conservative_raster_pre_snap_triangles); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glConservativeRasterParameteriNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlConservativeRasterParameteriNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlConservativeRasterParameteriNV)
}
var _ = atom.Atom(&GlDepthRangeArrayfvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangeArrayfvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangeArrayfvOES().
func (ϟa *GlDepthRangeArrayfvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangeArrayfvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangeArrayfvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangeArrayfvOES)
}
var _ = atom.Atom(&GlDepthRangeIndexedfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangeIndexedfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangeIndexedfOES().
func (ϟa *GlDepthRangeIndexedfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangeIndexedfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangeIndexedfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangeIndexedfOES)
}
var _ = atom.Atom(&GlDrawTransformFeedbackEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTransformFeedbackEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTransformFeedbackEXT().
func (ϟa *GlDrawTransformFeedbackEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_transform_feedback); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTransformFeedbackEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTransformFeedbackEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTransformFeedbackEXT)
}
var _ = atom.Atom(&GlDrawTransformFeedbackInstancedEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTransformFeedbackInstancedEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTransformFeedbackInstancedEXT().
func (ϟa *GlDrawTransformFeedbackInstancedEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_draw_transform_feedback); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTransformFeedbackInstancedEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTransformFeedbackInstancedEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Instancecount.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTransformFeedbackInstancedEXT)
}
var _ = atom.Atom(&GlFramebufferPixelLocalStorageSizeEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferPixelLocalStorageSizeEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferPixelLocalStorageSizeEXT().
func (ϟa *GlFramebufferPixelLocalStorageSizeEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_shader_pixel_local_storage2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferPixelLocalStorageSizeEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferPixelLocalStorageSizeEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Target.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferPixelLocalStorageSizeEXT)
}
var _ = atom.Atom(&GlFramebufferTexture2DDownsampleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture2DDownsampleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture2DDownsampleIMG().
func (ϟa *GlFramebufferTexture2DDownsampleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_framebuffer_downsample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture2DDownsampleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture2DDownsampleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Textarget))
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xscale.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yscale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture2DDownsampleIMG)
}
var _ = atom.Atom(&GlFramebufferTextureLayerDownsampleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureLayerDownsampleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureLayerDownsampleIMG().
func (ϟa *GlFramebufferTextureLayerDownsampleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_framebuffer_downsample); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureLayerDownsampleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureLayerDownsampleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xscale.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yscale.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureLayerDownsampleIMG)
}
var _ = atom.Atom(&GlFramebufferTextureMultisampleMultiviewOVR{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureMultisampleMultiviewOVR.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureMultisampleMultiviewOVR().
func (ϟa *GlFramebufferTextureMultisampleMultiviewOVR) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OVR_multiview_multisampled_render_to_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureMultisampleMultiviewOVR().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureMultisampleMultiviewOVR) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BaseViewIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumViews.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureMultisampleMultiviewOVR)
}
var _ = atom.Atom(&GlGetFloati_vOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFloati_vOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFloati_vOES().
func (ϟa *GlGetFloati_vOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFloati_vOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFloati_vOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFloati_vOES)
}
var _ = atom.Atom(&GlGetFramebufferPixelLocalStorageSizeEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFramebufferPixelLocalStorageSizeEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFramebufferPixelLocalStorageSizeEXT().
// Upon returning the glGetFramebufferPixelLocalStorageSizeEXT() return value will be stored on the stack.
func (ϟa *GlGetFramebufferPixelLocalStorageSizeEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_shader_pixel_local_storage2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFramebufferPixelLocalStorageSizeEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetFramebufferPixelLocalStorageSizeEXT() return value will be stored on the stack.
func (ϟa *GlGetFramebufferPixelLocalStorageSizeEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Target.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFramebufferPixelLocalStorageSizeEXT)
}
var _ = atom.Atom(&GlGetTextureHandleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTextureHandleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTextureHandleIMG().
// Upon returning the glGetTextureHandleIMG() return value will be stored on the stack.
func (ϟa *GlGetTextureHandleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTextureHandleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetTextureHandleIMG() return value will be stored on the stack.
func (ϟa *GlGetTextureHandleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTextureHandleIMG)
}
var _ = atom.Atom(&GlGetTextureSamplerHandleIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTextureSamplerHandleIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTextureSamplerHandleIMG().
// Upon returning the glGetTextureSamplerHandleIMG() return value will be stored on the stack.
func (ϟa *GlGetTextureSamplerHandleIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTextureSamplerHandleIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetTextureSamplerHandleIMG() return value will be stored on the stack.
func (ϟa *GlGetTextureSamplerHandleIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTextureSamplerHandleIMG)
}
var _ = atom.Atom(&GlGetUniformi64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformi64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformi64vNV().
func (ϟa *GlGetUniformi64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformi64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetUniformi64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetUniformi64vNV)
}
var _ = atom.Atom(&GlPolygonOffsetClampEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPolygonOffsetClampEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPolygonOffsetClampEXT().
func (ϟa *GlPolygonOffsetClampEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_polygon_offset_clamp); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPolygonOffsetClampEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPolygonOffsetClampEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Factor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Units.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Clamp.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPolygonOffsetClampEXT)
}
var _ = atom.Atom(&GlProgramUniform1i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1i64NV().
func (ϟa *GlProgramUniform1i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1i64NV)
}
var _ = atom.Atom(&GlProgramUniform1i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1i64vNV().
func (ϟa *GlProgramUniform1i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1i64vNV)
}
var _ = atom.Atom(&GlProgramUniform1ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1ui64NV().
func (ϟa *GlProgramUniform1ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1ui64NV)
}
var _ = atom.Atom(&GlProgramUniform1ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1ui64vNV().
func (ϟa *GlProgramUniform1ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1ui64vNV)
}
var _ = atom.Atom(&GlProgramUniform2i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2i64NV().
func (ϟa *GlProgramUniform2i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2i64NV)
}
var _ = atom.Atom(&GlProgramUniform2i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2i64vNV().
func (ϟa *GlProgramUniform2i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2i64vNV)
}
var _ = atom.Atom(&GlProgramUniform2ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2ui64NV().
func (ϟa *GlProgramUniform2ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2ui64NV)
}
var _ = atom.Atom(&GlProgramUniform2ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2ui64vNV().
func (ϟa *GlProgramUniform2ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2ui64vNV)
}
var _ = atom.Atom(&GlProgramUniform3i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3i64NV().
func (ϟa *GlProgramUniform3i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3i64NV)
}
var _ = atom.Atom(&GlProgramUniform3i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3i64vNV().
func (ϟa *GlProgramUniform3i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3i64vNV)
}
var _ = atom.Atom(&GlProgramUniform3ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3ui64NV().
func (ϟa *GlProgramUniform3ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3ui64NV)
}
var _ = atom.Atom(&GlProgramUniform3ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3ui64vNV().
func (ϟa *GlProgramUniform3ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3ui64vNV)
}
var _ = atom.Atom(&GlProgramUniform4i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4i64NV().
func (ϟa *GlProgramUniform4i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4i64NV)
}
var _ = atom.Atom(&GlProgramUniform4i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4i64vNV().
func (ϟa *GlProgramUniform4i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4i64vNV)
}
var _ = atom.Atom(&GlProgramUniform4ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4ui64NV().
func (ϟa *GlProgramUniform4ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4ui64NV)
}
var _ = atom.Atom(&GlProgramUniform4ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4ui64vNV().
func (ϟa *GlProgramUniform4ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4ui64vNV)
}
var _ = atom.Atom(&GlProgramUniformHandleui64IMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformHandleui64IMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformHandleui64IMG().
func (ϟa *GlProgramUniformHandleui64IMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformHandleui64IMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformHandleui64IMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformHandleui64IMG)
}
var _ = atom.Atom(&GlProgramUniformHandleui64vIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformHandleui64vIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformHandleui64vIMG().
func (ϟa *GlProgramUniformHandleui64vIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformHandleui64vIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformHandleui64vIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformHandleui64vIMG)
}
var _ = atom.Atom(&GlScissorArrayvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorArrayvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorArrayvOES().
func (ϟa *GlScissorArrayvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorArrayvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorArrayvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorArrayvOES)
}
var _ = atom.Atom(&GlScissorIndexedOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorIndexedOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorIndexedOES().
func (ϟa *GlScissorIndexedOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorIndexedOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorIndexedOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Left.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Bottom.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorIndexedOES)
}
var _ = atom.Atom(&GlScissorIndexedvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissorIndexedvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissorIndexedvOES().
func (ϟa *GlScissorIndexedvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissorIndexedvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissorIndexedvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissorIndexedvOES)
}
var _ = atom.Atom(&GlUniform1i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1i64NV().
func (ϟa *GlUniform1i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1i64NV)
}
var _ = atom.Atom(&GlUniform1i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1i64vNV().
func (ϟa *GlUniform1i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1i64vNV)
}
var _ = atom.Atom(&GlUniform1ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1ui64NV().
func (ϟa *GlUniform1ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1ui64NV)
}
var _ = atom.Atom(&GlUniform1ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1ui64vNV().
func (ϟa *GlUniform1ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1ui64vNV)
}
var _ = atom.Atom(&GlUniform2i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2i64NV().
func (ϟa *GlUniform2i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2i64NV)
}
var _ = atom.Atom(&GlUniform2i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2i64vNV().
func (ϟa *GlUniform2i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2i64vNV)
}
var _ = atom.Atom(&GlUniform2ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2ui64NV().
func (ϟa *GlUniform2ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2ui64NV)
}
var _ = atom.Atom(&GlUniform2ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2ui64vNV().
func (ϟa *GlUniform2ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2ui64vNV)
}
var _ = atom.Atom(&GlUniform3i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3i64NV().
func (ϟa *GlUniform3i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3i64NV)
}
var _ = atom.Atom(&GlUniform3i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3i64vNV().
func (ϟa *GlUniform3i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3i64vNV)
}
var _ = atom.Atom(&GlUniform3ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3ui64NV().
func (ϟa *GlUniform3ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3ui64NV)
}
var _ = atom.Atom(&GlUniform3ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3ui64vNV().
func (ϟa *GlUniform3ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3ui64vNV)
}
var _ = atom.Atom(&GlUniform4i64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4i64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4i64NV().
func (ϟa *GlUniform4i64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4i64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4i64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4i64NV)
}
var _ = atom.Atom(&GlUniform4i64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4i64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4i64vNV().
func (ϟa *GlUniform4i64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4i64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4i64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4i64vNV)
}
var _ = atom.Atom(&GlUniform4ui64NV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4ui64NV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4ui64NV().
func (ϟa *GlUniform4ui64NV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4ui64NV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4ui64NV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4ui64NV)
}
var _ = atom.Atom(&GlUniform4ui64vNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4ui64vNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4ui64vNV().
func (ϟa *GlUniform4ui64vNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_gpu_shader5); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4ui64vNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4ui64vNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4ui64vNV)
}
var _ = atom.Atom(&GlUniformHandleui64IMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformHandleui64IMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformHandleui64IMG().
func (ϟa *GlUniformHandleui64IMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformHandleui64IMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformHandleui64IMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformHandleui64IMG)
}
var _ = atom.Atom(&GlUniformHandleui64vIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformHandleui64vIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformHandleui64vIMG().
func (ϟa *GlUniformHandleui64vIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_bindless_texture); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformHandleui64vIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformHandleui64vIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformHandleui64vIMG)
}
var _ = atom.Atom(&GlViewportArrayvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportArrayvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportArrayvOES().
func (ϟa *GlViewportArrayvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportArrayvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportArrayvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.First.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportArrayvOES)
}
var _ = atom.Atom(&GlViewportIndexedfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportIndexedfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportIndexedfOES().
func (ϟa *GlViewportIndexedfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportIndexedfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportIndexedfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.H.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportIndexedfOES)
}
var _ = atom.Atom(&GlViewportIndexedfvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportIndexedfvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportIndexedfvOES().
func (ϟa *GlViewportIndexedfvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_viewport_array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportIndexedfvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportIndexedfvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewportIndexedfvOES)
}
var _ = atom.Atom(&GlViewportSwizzleNV{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewportSwizzleNV.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewportSwizzleNV().
func (ϟa *GlViewportSwizzleNV) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_NV_viewport_swizzle); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewportSwizzleNV().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewportSwizzleNV) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Swizzlex))
ϟb.Push(value.U32(ϟa.Swizzley))
ϟb.Push(value.U32(ϟa.Swizzlez))
ϟb.Push(value.U32(ϟa.Swizzlew))
ϟb.Call(funcInfoGlViewportSwizzleNV)
}
var _ = atom.Atom(&GlWindowRectanglesEXT{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWindowRectanglesEXT.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWindowRectanglesEXT().
func (ϟa *GlWindowRectanglesEXT) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_window_rectangles); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWindowRectanglesEXT().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWindowRectanglesEXT) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Box.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWindowRectanglesEXT)
}
var _ = atom.Atom(&GlBlendBarrier{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendBarrier.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendBarrier().
func (ϟa *GlBlendBarrier) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendBarrier(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendBarrier().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendBarrier) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlBlendBarrier)
}
var _ = atom.Atom(&GlBlendColor{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendColor.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendColor().
func (ϟa *GlBlendColor) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.BlendColor = Color{Red: ϟa.Red, Green: ϟa.Green, Blue: ϟa.Blue, Alpha: ϟa.Alpha}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendColor().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendColor) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBlendColor)
}
var _ = atom.Atom(&GlBlendEquation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquation().
func (ϟa *GlBlendEquation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, DrawBufferIndex(uint32(0)), int32(len(ctx.FragmentOperations.Blend)), ϟa.Equation, ϟa.Equation); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Equation))
ϟb.Call(funcInfoGlBlendEquation)
}
var _ = atom.Atom(&GlBlendEquationSeparate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationSeparate.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationSeparate().
func (ϟa *GlBlendEquationSeparate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetBlendEquation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, DrawBufferIndex(uint32(0)), int32(len(ctx.FragmentOperations.Blend)), ϟa.Rgb, ϟa.Alpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationSeparate().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationSeparate) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Rgb))
ϟb.Push(value.U32(ϟa.Alpha))
ϟb.Call(funcInfoGlBlendEquationSeparate)
}
var _ = atom.Atom(&GlBlendEquationSeparatei{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationSeparatei.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationSeparatei().
func (ϟa *GlBlendEquationSeparatei) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.ModeRGB, ϟa.ModeAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationSeparatei().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationSeparatei) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.ModeRGB))
ϟb.Push(value.U32(ϟa.ModeAlpha))
ϟb.Call(funcInfoGlBlendEquationSeparatei)
}
var _ = atom.Atom(&GlBlendEquationi{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationi.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationi().
func (ϟa *GlBlendEquationi) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendEquationi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Mode); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationi().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationi) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlBlendEquationi)
}
var _ = atom.Atom(&GlBlendFunc{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFunc.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFunc().
func (ϟa *GlBlendFunc) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, DrawBufferIndex(uint32(0)), int32(len(ctx.FragmentOperations.Blend)), ϟa.SrcFactor, ϟa.DstFactor, ϟa.SrcFactor, ϟa.DstFactor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFunc().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFunc) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.SrcFactor))
ϟb.Push(value.U32(ϟa.DstFactor))
ϟb.Call(funcInfoGlBlendFunc)
}
var _ = atom.Atom(&GlBlendFuncSeparate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFuncSeparate.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFuncSeparate().
func (ϟa *GlBlendFuncSeparate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subSetBlendFunc(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, DrawBufferIndex(uint32(0)), int32(len(ctx.FragmentOperations.Blend)), ϟa.SrcFactorRgb, ϟa.DstFactorRgb, ϟa.SrcFactorAlpha, ϟa.DstFactorAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFuncSeparate().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFuncSeparate) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.SrcFactorRgb))
ϟb.Push(value.U32(ϟa.DstFactorRgb))
ϟb.Push(value.U32(ϟa.SrcFactorAlpha))
ϟb.Push(value.U32(ϟa.DstFactorAlpha))
ϟb.Call(funcInfoGlBlendFuncSeparate)
}
var _ = atom.Atom(&GlBlendFuncSeparatei{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFuncSeparatei.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFuncSeparatei().
func (ϟa *GlBlendFuncSeparatei) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFuncSeparatei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.SrcRGB, ϟa.DstRGB, ϟa.SrcAlpha, ϟa.DstAlpha); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFuncSeparatei().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFuncSeparatei) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcRGB))
ϟb.Push(value.U32(ϟa.DstRGB))
ϟb.Push(value.U32(ϟa.SrcAlpha))
ϟb.Push(value.U32(ϟa.DstAlpha))
ϟb.Call(funcInfoGlBlendFuncSeparatei)
}
var _ = atom.Atom(&GlBlendFunci{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFunci.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFunci().
func (ϟa *GlBlendFunci) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlendFunci(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buf, ϟa.Src, ϟa.Dst); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFunci().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFunci) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Buf.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Src))
ϟb.Push(value.U32(ϟa.Dst))
ϟb.Call(funcInfoGlBlendFunci)
}
var _ = atom.Atom(&GlDepthFunc{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthFunc.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthFunc().
func (ϟa *GlDepthFunc) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Function {
case GLenum_GL_ALWAYS, GLenum_GL_EQUAL, GLenum_GL_GEQUAL, GLenum_GL_GREATER, GLenum_GL_LEQUAL, GLenum_GL_LESS, GLenum_GL_NEVER, GLenum_GL_NOTEQUAL:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Function); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Depth.Func = ϟa.Function
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthFunc().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthFunc) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Function))
ϟb.Call(funcInfoGlDepthFunc)
}
var _ = atom.Atom(&GlSampleCoverage{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSampleCoverage.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSampleCoverage().
func (ϟa *GlSampleCoverage) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.SampleCoverageValue = ϟa.Value
ctx.Rasterization.SampleCoverageInvert = ϟa.Invert
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSampleCoverage().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSampleCoverage) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Invert.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSampleCoverage)
}
var _ = atom.Atom(&GlSampleMaski{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSampleMaski.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSampleMaski().
func (ϟa *GlSampleMaski) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.SampleMaskValue[ϟa.MaskNumber] = ϟa.Mask
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSampleMaski().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSampleMaski) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.MaskNumber.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Call(funcInfoGlSampleMaski)
}
var _ = atom.Atom(&GlScissor{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScissor.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScissor().
func (ϟa *GlScissor) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ((ϟa.Width) < (GLsizei(int32(0)))) || ((ϟa.Height) < (GLsizei(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.FragmentOperations.Scissor.Box = Rect{X: ϟa.X, Y: ϟa.Y, Width: ϟa.Width, Height: ϟa.Height}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScissor().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScissor) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScissor)
}
var _ = atom.Atom(&GlStencilFunc{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilFunc.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilFunc().
func (ϟa *GlStencilFunc) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subStencilFuncSeparate(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_FRONT_AND_BACK, ϟa.Func, ϟa.Ref, ϟa.Mask); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilFunc().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilFunc) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilFunc)
}
var _ = atom.Atom(&GlStencilFuncSeparate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilFuncSeparate.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilFuncSeparate().
func (ϟa *GlStencilFuncSeparate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subStencilFuncSeparate(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Face, ϟa.Function, ϟa.ReferenceValue, ϟa.Mask); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilFuncSeparate().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilFuncSeparate) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Function))
ϟb.Push(ϟa.ReferenceValue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilFuncSeparate)
}
var _ = atom.Atom(&GlStencilOp{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilOp.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilOp().
func (ϟa *GlStencilOp) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subStencilOpSeparate(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_FRONT_AND_BACK, ϟa.Fail, ϟa.Zfail, ϟa.Zpass); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilOp().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilOp) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Fail))
ϟb.Push(value.U32(ϟa.Zfail))
ϟb.Push(value.U32(ϟa.Zpass))
ϟb.Call(funcInfoGlStencilOp)
}
var _ = atom.Atom(&GlStencilOpSeparate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilOpSeparate.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilOpSeparate().
func (ϟa *GlStencilOpSeparate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subStencilOpSeparate(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Face, ϟa.StencilFail, ϟa.StencilPassDepthFail, ϟa.StencilPassDepthPass); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilOpSeparate().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilOpSeparate) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.StencilFail))
ϟb.Push(value.U32(ϟa.StencilPassDepthFail))
ϟb.Push(value.U32(ϟa.StencilPassDepthPass))
ϟb.Call(funcInfoGlStencilOpSeparate)
}
var _ = atom.Atom(&GlBindFramebuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindFramebuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindFramebuffer().
func (ϟa *GlBindFramebuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_FRAMEBUFFER:
case GLenum_GL_DRAW_FRAMEBUFFER, GLenum_GL_READ_FRAMEBUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer)) {
ctx.Instances.Framebuffers[ϟa.Framebuffer] = &Framebuffer{Attachments: GLenumːFramebufferAttachmentᵐ{}, DrawBuffer: GLintːGLenumᵐ{}, ReadBuffer: GLenum_GL_COLOR_ATTACHMENT0, DefaultWidth: GLint(int32(0)), DefaultHeight: GLint(int32(0)), DefaultLayers: GLint(int32(0)), DefaultSamples: GLint(int32(0)), DefaultFixedSampleLocations: GLboolean_GL_FALSE}
}
if (ϟa.Target) == (GLenum_GL_FRAMEBUFFER) {
ctx.BoundFramebuffers[GLenum_GL_READ_FRAMEBUFFER] = ϟa.Framebuffer
ctx.BoundFramebuffers[GLenum_GL_DRAW_FRAMEBUFFER] = ϟa.Framebuffer
} else {
ctx.BoundFramebuffers[ϟa.Target] = ϟa.Framebuffer
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindFramebuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindFramebuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Framebuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindFramebuffer)
}
var _ = atom.Atom(&GlBindRenderbuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindRenderbuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindRenderbuffer().
func (ϟa *GlBindRenderbuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_RENDERBUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer)) {
ctx.Instances.Renderbuffers[ϟa.Renderbuffer] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
}
ctx.BoundRenderbuffers[ϟa.Target] = ϟa.Renderbuffer
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindRenderbuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindRenderbuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Renderbuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindRenderbuffer)
}
var _ = atom.Atom(&GlBlitFramebuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlitFramebuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlitFramebuffer().
func (ϟa *GlBlitFramebuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBlitFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.SrcX0, ϟa.SrcY0, ϟa.SrcX1, ϟa.SrcY1, ϟa.DstX0, ϟa.DstY0, ϟa.DstX1, ϟa.DstY1, ϟa.Mask, ϟa.Filter); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlitFramebuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlitFramebuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY1.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Push(value.U32(ϟa.Filter))
ϟb.Call(funcInfoGlBlitFramebuffer)
}
var _ = atom.Atom(&GlCheckFramebufferStatus{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCheckFramebufferStatus.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCheckFramebufferStatus().
// Upon returning the glCheckFramebufferStatus() return value will be stored on the stack.
func (ϟa *GlCheckFramebufferStatus) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_FRAMEBUFFER:
case GLenum_GL_DRAW_FRAMEBUFFER, GLenum_GL_READ_FRAMEBUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCheckFramebufferStatus().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCheckFramebufferStatus() return value will be stored on the stack.
func (ϟa *GlCheckFramebufferStatus) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlCheckFramebufferStatus)
}
var _ = atom.Atom(&GlClear{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClear.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClear().
func (ϟa *GlClear) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mask, (GLbitfield_GL_COLOR_BUFFER_BIT)|((GLbitfield_GL_DEPTH_BUFFER_BIT)|(GLbitfield_GL_STENCIL_BUFFER_BIT))); ϟerr != nil {
return ϟerr
}
if (GLbitfield_GL_COLOR_BUFFER_BIT)&(ϟa.Mask) != 0 {
}
if (GLbitfield_GL_DEPTH_BUFFER_BIT)&(ϟa.Mask) != 0 {
}
if (GLbitfield_GL_STENCIL_BUFFER_BIT)&(ϟa.Mask) != 0 {
}
if (GLbitfield_GL_COLOR_BUFFER_BIT)&(ϟa.Mask) != 0 {
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClear().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClear) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Call(funcInfoGlClear)
}
var _ = atom.Atom(&GlClearBufferfi{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearBufferfi.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearBufferfi().
func (ϟa *GlClearBufferfi) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Buffer {
case GLenum_GL_DEPTH_STENCIL:
if (ϟa.Drawbuffer) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearBufferfi().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearBufferfi) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Buffer))
ϟb.Push(ϟa.Drawbuffer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stencil.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearBufferfi)
}
var _ = atom.Atom(&GlClearBufferfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearBufferfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearBufferfv().
func (ϟa *GlClearBufferfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Buffer {
case GLenum_GL_COLOR:
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Drawbuffer) >= (ctx.Constants.MaxDrawBuffers) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ϟa.Value.Slice(uint64(0), uint64(4), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_DEPTH:
if (ϟa.Drawbuffer) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearBufferfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearBufferfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Buffer))
ϟb.Push(ϟa.Drawbuffer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearBufferfv)
}
var _ = atom.Atom(&GlClearBufferiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearBufferiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearBufferiv().
func (ϟa *GlClearBufferiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Buffer {
case GLenum_GL_COLOR:
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Drawbuffer) >= (ctx.Constants.MaxDrawBuffers) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ϟa.Value.Slice(uint64(0), uint64(4), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
case GLenum_GL_STENCIL:
if (ϟa.Drawbuffer) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearBufferiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearBufferiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Buffer))
ϟb.Push(ϟa.Drawbuffer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearBufferiv)
}
var _ = atom.Atom(&GlClearBufferuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearBufferuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearBufferuiv().
func (ϟa *GlClearBufferuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Buffer {
case GLenum_GL_COLOR:
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Drawbuffer) >= (ctx.Constants.MaxDrawBuffers) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ϟa.Value.Slice(uint64(0), uint64(4), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearBufferuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearBufferuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Buffer))
ϟb.Push(ϟa.Drawbuffer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearBufferuiv)
}
var _ = atom.Atom(&GlClearColor{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearColor.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearColor().
func (ϟa *GlClearColor) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.ColorClearValue = Vec4f{Elements: [4]GLfloat{ϟa.R, ϟa.G, ϟa.B, ϟa.A}}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearColor().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearColor) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.G.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.A.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearColor)
}
var _ = atom.Atom(&GlClearDepthf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearDepthf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearDepthf().
func (ϟa *GlClearDepthf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.DepthClearValue = ϟa.Depth
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearDepthf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearDepthf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearDepthf)
}
var _ = atom.Atom(&GlClearStencil{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearStencil.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearStencil().
func (ϟa *GlClearStencil) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.StencilClearValue = ϟa.Stencil
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearStencil().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearStencil) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Stencil.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearStencil)
}
var _ = atom.Atom(&GlColorMask{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorMask.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorMask().
func (ϟa *GlColorMask) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := DrawBufferIndex(uint32(0)); i < DrawBufferIndex(uint32(len(ctx.Framebuffer.ColorWritemask))); i++ {
ctx.Framebuffer.ColorWritemask[i] = Vec4b{Elements: [4]GLboolean{ϟa.Red, ϟa.Green, ϟa.Blue, ϟa.Alpha}}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorMask().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorMask) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorMask)
}
var _ = atom.Atom(&GlColorMaski{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorMaski.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorMaski().
func (ϟa *GlColorMaski) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subColorMaski(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.R, ϟa.G, ϟa.B, ϟa.A); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorMaski().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorMaski) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.G.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.A.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorMaski)
}
var _ = atom.Atom(&GlDeleteFramebuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteFramebuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteFramebuffers().
func (ϟa *GlDeleteFramebuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
f := ϟa.Framebuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := f.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (FramebufferId(uint32(0))) {
delete(ctx.Instances.Framebuffers, id)
if (id) == (ctx.BoundFramebuffers.Get(GLenum_GL_READ_FRAMEBUFFER)) {
ctx.BoundFramebuffers[GLenum_GL_READ_FRAMEBUFFER] = FramebufferId(uint32(0))
}
if (id) == (ctx.BoundFramebuffers.Get(GLenum_GL_DRAW_FRAMEBUFFER)) {
ctx.BoundFramebuffers[GLenum_GL_DRAW_FRAMEBUFFER] = FramebufferId(uint32(0))
}
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteFramebuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteFramebuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Framebuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteFramebuffers)
}
var _ = atom.Atom(&GlDeleteRenderbuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteRenderbuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteRenderbuffers().
func (ϟa *GlDeleteRenderbuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
r := ϟa.Renderbuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := r.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (RenderbufferId(uint32(0))) {
delete(ctx.Instances.Renderbuffers, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteRenderbuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteRenderbuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Renderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteRenderbuffers)
}
var _ = atom.Atom(&GlDepthMask{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthMask.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthMask().
func (ϟa *GlDepthMask) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.DepthWritemask = ϟa.Enabled
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthMask().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthMask) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Enabled.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthMask)
}
var _ = atom.Atom(&GlDrawBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawBuffers().
func (ϟa *GlDrawBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDrawBuffers(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.N, ϟa.Bufs); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawBuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawBuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Bufs.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawBuffers)
}
var _ = atom.Atom(&GlFramebufferParameteri{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferParameteri.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferParameteri().
func (ϟa *GlFramebufferParameteri) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsDefaultFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffer)
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Pname {
case GLenum_GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
framebuffer.DefaultFixedSampleLocations = GLboolean(ϟa.Param)
case GLenum_GL_FRAMEBUFFER_DEFAULT_HEIGHT:
framebuffer.DefaultHeight = ϟa.Param
case GLenum_GL_FRAMEBUFFER_DEFAULT_SAMPLES:
framebuffer.DefaultSamples = ϟa.Param
case GLenum_GL_FRAMEBUFFER_DEFAULT_WIDTH:
framebuffer.DefaultWidth = ϟa.Param
case GLenum_GL_FRAMEBUFFER_DEFAULT_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
framebuffer.DefaultLayers = ϟa.Param
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferParameteri().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferParameteri) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferParameteri)
}
var _ = atom.Atom(&GlFramebufferRenderbuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferRenderbuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferRenderbuffer().
func (ϟa *GlFramebufferRenderbuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.FramebufferAttachment {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
case GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH_STENCIL_ATTACHMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.FramebufferAttachment); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.RenderbufferTarget) != (GLenum_GL_RENDERBUFFER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.RenderbufferTarget); ϟerr != nil {
return ϟerr
}
}
if ((ϟa.Renderbuffer) != (RenderbufferId(uint32(0)))) && (!(ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
attachment := FramebufferAttachment{ObjectType: GLenum_GL_NONE, ObjectName: GLuint(uint32(0)), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
if (ϟa.Renderbuffer) != (RenderbufferId(uint32(0))) {
attachment.ObjectType = GLenum_GL_RENDERBUFFER
attachment.ObjectName = GLuint(ϟa.Renderbuffer)
}
if ϟerr := subSetFramebufferAttachment(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.FramebufferTarget, ϟa.FramebufferAttachment, attachment); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferRenderbuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferRenderbuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.FramebufferTarget))
ϟb.Push(value.U32(ϟa.FramebufferAttachment))
ϟb.Push(value.U32(ϟa.RenderbufferTarget))
if key, remap := ϟa.Renderbuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlFramebufferRenderbuffer)
}
var _ = atom.Atom(&GlFramebufferTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture().
func (ϟa *GlFramebufferTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture)
}
var _ = atom.Atom(&GlFramebufferTexture2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture2D().
func (ϟa *GlFramebufferTexture2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture2D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.FramebufferTarget, ϟa.FramebufferAttachment, ϟa.TextureTarget, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.FramebufferTarget))
ϟb.Push(value.U32(ϟa.FramebufferAttachment))
ϟb.Push(value.U32(ϟa.TextureTarget))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture2D)
}
var _ = atom.Atom(&GlFramebufferTextureLayer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTextureLayer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTextureLayer().
func (ϟa *GlFramebufferTextureLayer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Attachment {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_DEPTH_STENCIL_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Attachment); ϟerr != nil {
return ϟerr
}
}
attachment_info := FramebufferAttachment{ObjectType: GLenum_GL_NONE, ObjectName: GLuint(uint32(0)), TextureLevel: GLint(int32(0)), TextureCubeMapFace: GLenum_GL_NONE, TextureLayer: GLint(int32(0)), Layered: GLboolean_GL_FALSE}
if (ϟa.Texture) != (TextureId(uint32(0))) {
attachment_info.ObjectType = GLenum_GL_TEXTURE
attachment_info.ObjectName = GLuint(ϟa.Texture)
attachment_info.TextureLevel = ϟa.Level
attachment_info.TextureLayer = ϟa.Layer
}
if ϟerr := subSetFramebufferAttachment(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, attachment_info); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTextureLayer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTextureLayer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTextureLayer)
}
var _ = atom.Atom(&GlGenFramebuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenFramebuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenFramebuffers().
func (ϟa *GlGenFramebuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
f := ϟa.Framebuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := FramebufferId(ϟa.Framebuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Framebuffers[id] = &Framebuffer{Attachments: GLenumːFramebufferAttachmentᵐ{}, DrawBuffer: GLintːGLenumᵐ{}, ReadBuffer: GLenum_GL_COLOR_ATTACHMENT0, DefaultWidth: GLint(int32(0)), DefaultHeight: GLint(int32(0)), DefaultLayers: GLint(int32(0)), DefaultSamples: GLint(int32(0)), DefaultFixedSampleLocations: GLboolean_GL_FALSE}
f.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenFramebuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenFramebuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Framebuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenFramebuffers)
}
var _ = atom.Atom(&GlGenRenderbuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenRenderbuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenRenderbuffers().
func (ϟa *GlGenRenderbuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
r := ϟa.Renderbuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := RenderbufferId(ϟa.Renderbuffers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Renderbuffers[id] = &Renderbuffer{Width: GLsizei(int32(0)), Height: GLsizei(int32(0)), InternalFormat: GLenum_GL_RGBA4}
r.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenRenderbuffers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenRenderbuffers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Renderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenRenderbuffers)
}
var _ = atom.Atom(&GlGetFramebufferAttachmentParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFramebufferAttachmentParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFramebufferAttachmentParameteriv().
func (ϟa *GlGetFramebufferAttachmentParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Attachment {
case GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_DEPTH_ATTACHMENT, GLenum_GL_STENCIL_ATTACHMENT:
case GLenum_GL_BACK, GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_DEPTH, GLenum_GL_DEPTH_STENCIL_ATTACHMENT, GLenum_GL_STENCIL:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Attachment); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Parameter {
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, GLenum_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_LAYERED:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.FramebufferTarget)
if ϟerr != nil {
return ϟerr
}
a := framebuffer.Attachments.Get(ϟa.Attachment)
if ((a.ObjectType) == (GLenum_GL_NONE)) && (((ϟa.Parameter) != (GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)) && ((ϟa.Parameter) != (GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, func() (result GLint) {
switch ϟa.Parameter {
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
return GLint(a.ObjectType)
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
return GLint(a.ObjectName)
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
return a.TextureLevel
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
return GLint(a.TextureCubeMapFace)
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_LAYERED:
return GLint(a.Layered)
case GLenum_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
return a.TextureLayer
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFramebufferAttachmentParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFramebufferAttachmentParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.FramebufferTarget))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFramebufferAttachmentParameteriv)
}
var _ = atom.Atom(&GlGetFramebufferParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFramebufferParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFramebufferParameteriv().
func (ϟa *GlGetFramebufferParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Pname {
case GLenum_GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS, GLenum_GL_FRAMEBUFFER_DEFAULT_HEIGHT, GLenum_GL_FRAMEBUFFER_DEFAULT_SAMPLES, GLenum_GL_FRAMEBUFFER_DEFAULT_WIDTH:
case GLenum_GL_FRAMEBUFFER_DEFAULT_LAYERS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsDefaultFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, framebuffer)
if ϟerr != nil {
return ϟerr
}
if _res_0 {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, func() (result GLint) {
switch ϟa.Pname {
case GLenum_GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
return GLint(framebuffer.DefaultFixedSampleLocations)
case GLenum_GL_FRAMEBUFFER_DEFAULT_HEIGHT:
return framebuffer.DefaultHeight
case GLenum_GL_FRAMEBUFFER_DEFAULT_SAMPLES:
return framebuffer.DefaultSamples
case GLenum_GL_FRAMEBUFFER_DEFAULT_WIDTH:
return framebuffer.DefaultWidth
case GLenum_GL_FRAMEBUFFER_DEFAULT_LAYERS:
return framebuffer.DefaultLayers
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Pname, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFramebufferParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFramebufferParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFramebufferParameteriv)
}
var _ = atom.Atom(&GlGetRenderbufferParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetRenderbufferParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetRenderbufferParameteriv().
func (ϟa *GlGetRenderbufferParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_RENDERBUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Parameter {
case GLenum_GL_RENDERBUFFER_ALPHA_SIZE, GLenum_GL_RENDERBUFFER_BLUE_SIZE, GLenum_GL_RENDERBUFFER_DEPTH_SIZE, GLenum_GL_RENDERBUFFER_GREEN_SIZE, GLenum_GL_RENDERBUFFER_HEIGHT, GLenum_GL_RENDERBUFFER_INTERNAL_FORMAT, GLenum_GL_RENDERBUFFER_RED_SIZE, GLenum_GL_RENDERBUFFER_STENCIL_SIZE, GLenum_GL_RENDERBUFFER_WIDTH:
case GLenum_GL_RENDERBUFFER_SAMPLES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
id := ctx.BoundRenderbuffers.Get(ϟa.Target)
if (id) == (RenderbufferId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
rb := ctx.Instances.Renderbuffers.Get(id)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, func() (result GLint) {
switch ϟa.Parameter {
case GLenum_GL_RENDERBUFFER_WIDTH:
return GLint(rb.Width)
case GLenum_GL_RENDERBUFFER_HEIGHT:
return GLint(rb.Height)
case GLenum_GL_RENDERBUFFER_INTERNAL_FORMAT:
return GLint(rb.InternalFormat)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetRenderbufferParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetRenderbufferParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetRenderbufferParameteriv)
}
var _ = atom.Atom(&GlInvalidateFramebuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glInvalidateFramebuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glInvalidateFramebuffer().
func (ϟa *GlInvalidateFramebuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subInvalidateFramebuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Count, ϟa.Attachments); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glInvalidateFramebuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlInvalidateFramebuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Attachments.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlInvalidateFramebuffer)
}
var _ = atom.Atom(&GlInvalidateSubFramebuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glInvalidateSubFramebuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glInvalidateSubFramebuffer().
func (ϟa *GlInvalidateSubFramebuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_FRAMEBUFFER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ϟa.Attachments.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.NumAttachments), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glInvalidateSubFramebuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlInvalidateSubFramebuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.NumAttachments.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Attachments.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlInvalidateSubFramebuffer)
}
var _ = atom.Atom(&GlIsFramebuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsFramebuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsFramebuffer().
// Upon returning the glIsFramebuffer() return value will be stored on the stack.
func (ϟa *GlIsFramebuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsFramebuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsFramebuffer() return value will be stored on the stack.
func (ϟa *GlIsFramebuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Framebuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsFramebuffer)
}
var _ = atom.Atom(&GlIsRenderbuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsRenderbuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsRenderbuffer().
// Upon returning the glIsRenderbuffer() return value will be stored on the stack.
func (ϟa *GlIsRenderbuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsRenderbuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsRenderbuffer() return value will be stored on the stack.
func (ϟa *GlIsRenderbuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Renderbuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsRenderbuffer)
}
var _ = atom.Atom(&GlReadBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadBuffer().
func (ϟa *GlReadBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Src {
case GLenum_GL_BACK, GLenum_GL_COLOR_ATTACHMENT0, GLenum_GL_COLOR_ATTACHMENT1, GLenum_GL_COLOR_ATTACHMENT10, GLenum_GL_COLOR_ATTACHMENT11, GLenum_GL_COLOR_ATTACHMENT12, GLenum_GL_COLOR_ATTACHMENT13, GLenum_GL_COLOR_ATTACHMENT14, GLenum_GL_COLOR_ATTACHMENT15, GLenum_GL_COLOR_ATTACHMENT2, GLenum_GL_COLOR_ATTACHMENT3, GLenum_GL_COLOR_ATTACHMENT4, GLenum_GL_COLOR_ATTACHMENT5, GLenum_GL_COLOR_ATTACHMENT6, GLenum_GL_COLOR_ATTACHMENT7, GLenum_GL_COLOR_ATTACHMENT8, GLenum_GL_COLOR_ATTACHMENT9, GLenum_GL_NONE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Src); ϟerr != nil {
return ϟerr
}
}
framebuffer, ϟerr := subGetBoundFramebufferOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_READ_FRAMEBUFFER)
if ϟerr != nil {
return ϟerr
}
framebuffer.ReadBuffer = ϟa.Src
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Src))
ϟb.Call(funcInfoGlReadBuffer)
}
var _ = atom.Atom(&GlReadPixels{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadPixels.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadPixels().
func (ϟa *GlReadPixels) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckReadPixels(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Width, ϟa.Height, ϟa.Format, ϟa.Type); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ((ctx.BoundBuffers.PixelPackBuffer) == (BufferId(uint32(0)))) && ((ϟa.Data) != (Voidᵖ{})) {
requiredSize, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
ϟa.Data.Slice(uint64(uint32(0)), uint64(requiredSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadPixels().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadPixels) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlReadPixels)
}
var _ = atom.Atom(&GlReadnPixels{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReadnPixels.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReadnPixels().
func (ϟa *GlReadnPixels) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subReadnPixels(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.X, ϟa.Y, ϟa.Width, ϟa.Height, ϟa.Format, ϟa.Type, ϟa.BufSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReadnPixels().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReadnPixels) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlReadnPixels)
}
var _ = atom.Atom(&GlRenderbufferStorage{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorage.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorage().
func (ϟa *GlRenderbufferStorage) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subRenderbufferStorageMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, GLsizei(int32(0)), ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorage().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorage) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorage)
}
var _ = atom.Atom(&GlRenderbufferStorageMultisample{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageMultisample.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageMultisample().
func (ϟa *GlRenderbufferStorageMultisample) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subRenderbufferStorageMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Samples, ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageMultisample().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageMultisample) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageMultisample)
}
var _ = atom.Atom(&GlStencilMask{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilMask.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilMask().
func (ϟa *GlStencilMask) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Framebuffer.StencilWritemask = ϟa.Mask
ctx.Framebuffer.StencilBackWritemask = ϟa.Mask
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilMask().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilMask) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilMask)
}
var _ = atom.Atom(&GlStencilMaskSeparate{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glStencilMaskSeparate.
// If ϟb is not nil, Mutate also emits the replay instructions to call glStencilMaskSeparate().
func (ϟa *GlStencilMaskSeparate) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Face {
case GLenum_GL_BACK:
ctx.Framebuffer.StencilBackWritemask = ϟa.Mask
case GLenum_GL_FRONT:
ctx.Framebuffer.StencilWritemask = ϟa.Mask
case GLenum_GL_FRONT_AND_BACK:
ctx.Framebuffer.StencilWritemask = ϟa.Mask
ctx.Framebuffer.StencilBackWritemask = ϟa.Mask
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Face); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glStencilMaskSeparate().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlStencilMaskSeparate) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(ϟa.Mask.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlStencilMaskSeparate)
}
var _ = atom.Atom(&GlDisable{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisable.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisable().
func (ϟa *GlDisable) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, false, GLuint(uint32(0)), GLboolean_GL_FALSE); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisable().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisable) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Call(funcInfoGlDisable)
}
var _ = atom.Atom(&GlDisablei{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisablei.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisablei().
func (ϟa *GlDisablei) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDisablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisablei().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisablei) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisablei)
}
var _ = atom.Atom(&GlEnable{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnable.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnable().
func (ϟa *GlEnable) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, false, GLuint(uint32(0)), GLboolean_GL_TRUE); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnable().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnable) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Call(funcInfoGlEnable)
}
var _ = atom.Atom(&GlEnablei{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnablei.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnablei().
func (ϟa *GlEnablei) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subEnablei(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, ϟa.Index); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnablei().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnablei) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnablei)
}
var _ = atom.Atom(&GlFinish{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFinish.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFinish().
func (ϟa *GlFinish) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFinish().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFinish) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlFinish)
}
var _ = atom.Atom(&GlFlush{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFlush.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFlush().
func (ϟa *GlFlush) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFlush().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFlush) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlFlush)
}
var _ = atom.Atom(&GlGetError{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetError.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetError().
// Upon returning the glGetError() return value will be stored on the stack.
func (ϟa *GlGetError) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetError().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetError() return value will be stored on the stack.
func (ϟa *GlGetError) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlGetError)
}
var _ = atom.Atom(&GlGetGraphicsResetStatus{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetGraphicsResetStatus.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetGraphicsResetStatus().
// Upon returning the glGetGraphicsResetStatus() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatus) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subGetGraphicsResetStatus(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetGraphicsResetStatus().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetGraphicsResetStatus() return value will be stored on the stack.
func (ϟa *GlGetGraphicsResetStatus) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlGetGraphicsResetStatus)
}
var _ = atom.Atom(&GlHint{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glHint.
// If ϟb is not nil, Mutate also emits the replay instructions to call glHint().
func (ϟa *GlHint) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Mode {
case GLenum_GL_DONT_CARE, GLenum_GL_FASTEST, GLenum_GL_NICEST:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_GENERATE_MIPMAP_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Miscellaneous.GenerateMipmapHint = ϟa.Mode
case GLenum_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.Miscellaneous.FragmentShaderDerivativeHint = ϟa.Mode
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glHint().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlHint) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlHint)
}
var _ = atom.Atom(&GlActiveShaderProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glActiveShaderProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glActiveShaderProgram().
func (ϟa *GlActiveShaderProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glActiveShaderProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlActiveShaderProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlActiveShaderProgram)
}
var _ = atom.Atom(&GlAttachShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glAttachShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glAttachShader().
func (ϟa *GlAttachShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
p := ctx.Instances.Programs.Get(ϟa.Program)
s := ctx.Instances.Shaders.Get(ϟa.Shader)
if p.OnAccess(ϟs).Shaders.Contains(s.OnAccess(ϟs).Type) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
p.OnAccess(ϟs).Shaders[s.OnAccess(ϟs).Type] = ϟa.Shader
s.OnAccess(ϟs).RefCount += GLuint(uint32(1))
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glAttachShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlAttachShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlAttachShader)
}
var _ = atom.Atom(&GlBindAttribLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindAttribLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindAttribLocation().
func (ϟa *GlBindAttribLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
n := MakeCharˢFromString(ϟa.Name, ϟs)
if ((int32(n.Count)) > (int32(2))) && ((string(gfxapi.CharToBytes(n.Slice(uint64(0), uint64(3), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))) == ("gl_")) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if (ϟa.Location) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
p := ctx.Instances.Programs.Get(ϟa.Program)
p.OnAccess(ϟs).AttributeBindings[ϟa.Name] = ϟa.Location
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindAttribLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindAttribLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlBindAttribLocation)
}
var _ = atom.Atom(&GlBindProgramPipeline{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindProgramPipeline.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindProgramPipeline().
func (ϟa *GlBindProgramPipeline) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindProgramPipeline().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindProgramPipeline) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindProgramPipeline)
}
var _ = atom.Atom(&GlCompileShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompileShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompileShader().
func (ϟa *GlCompileShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompileShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompileShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlCompileShader)
}
var _ = atom.Atom(&GlCreateProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCreateProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCreateProgram().
// Upon returning the glCreateProgram() return value will be stored on the stack.
func (ϟa *GlCreateProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
id := ϟa.Result
ctx.Instances.Programs[id] = (&Program{ID: id, Shaders: GLenumːShaderIdᵐ{}, AttributeBindings: StringːAttributeLocationᵐ{}, ActiveAttributes: AttributeIndexːActiveAttributeᵐ{}, ActiveUniforms: UniformIndexːActiveUniformᵐ{}, Uniforms: UniformLocationːUniformᵐ{}}).OnCreate(ϟs)
_ = id
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCreateProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCreateProgram() return value will be stored on the stack.
func (ϟa *GlCreateProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlCreateProgram)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(4))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlCreateShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCreateShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCreateShader().
// Upon returning the glCreateShader() return value will be stored on the stack.
func (ϟa *GlCreateShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Type {
case GLenum_GL_FRAGMENT_SHADER, GLenum_GL_VERTEX_SHADER:
case GLenum_GL_COMPUTE_SHADER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_GEOMETRY_SHADER, GLenum_GL_TESS_CONTROL_SHADER, GLenum_GL_TESS_EVALUATION_SHADER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
id := ϟa.Result
ctx.Instances.Shaders[id] = (&Shader{ID: id, ShaderType: ϟa.Type, Compiled: false}).OnCreate(ϟs)
s := ctx.Instances.Shaders.Get(id)
s.OnAccess(ϟs).Type = ϟa.Type
_ = id
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCreateShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCreateShader() return value will be stored on the stack.
func (ϟa *GlCreateShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Call(funcInfoGlCreateShader)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(4))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlCreateShaderProgramv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCreateShaderProgramv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCreateShaderProgramv().
// Upon returning the glCreateShaderProgramv() return value will be stored on the stack.
func (ϟa *GlCreateShaderProgramv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Type {
case GLenum_GL_COMPUTE_SHADER, GLenum_GL_FRAGMENT_SHADER, GLenum_GL_VERTEX_SHADER:
case GLenum_GL_GEOMETRY_SHADER, GLenum_GL_TESS_CONTROL_SHADER, GLenum_GL_TESS_EVALUATION_SHADER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
sources := ϟa.Strings.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(sources.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCreateShaderProgramv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCreateShaderProgramv() return value will be stored on the stack.
func (ϟa *GlCreateShaderProgramv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Strings.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCreateShaderProgramv)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(4))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlDeleteProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteProgram().
func (ϟa *GlDeleteProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Program) != (ProgramId(uint32(0))) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
ctx.Instances.Programs.Get(ϟa.Program).OnAccess(ϟs).DeleteStatus = true
if (ctx.BoundProgram) != (ϟa.Program) {
if ϟerr := subReapProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteProgram)
}
var _ = atom.Atom(&GlDeleteProgramPipelines{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteProgramPipelines.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteProgramPipelines().
func (ϟa *GlDeleteProgramPipelines) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ϟa.Pipelines.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.N), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteProgramPipelines().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteProgramPipelines) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pipelines.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteProgramPipelines)
}
var _ = atom.Atom(&GlDeleteShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteShader().
func (ϟa *GlDeleteShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Shader) != (ShaderId(uint32(0))) {
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if ctx.Instances.Shaders.Contains(ϟa.Shader) {
s := ctx.Instances.Shaders.Get(ϟa.Shader)
s.OnAccess(ϟs).DeleteStatus = true
if ϟerr := subReapShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader, s); ϟerr != nil {
return ϟerr
}
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteShader)
}
var _ = atom.Atom(&GlDetachShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDetachShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDetachShader().
func (ϟa *GlDetachShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Shaders.Get(ϟa.Shader)
p := ctx.Instances.Programs.Get(ϟa.Program)
if (!(p.OnAccess(ϟs).Shaders.Contains(s.OnAccess(ϟs).Type))) || ((p.OnAccess(ϟs).Shaders.Get(s.OnAccess(ϟs).Type)) != (ϟa.Shader)) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
delete(p.OnAccess(ϟs).Shaders, s.OnAccess(ϟs).Type)
s.OnAccess(ϟs).RefCount -= GLuint(uint32(1))
if ϟerr := subReapShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader, s); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDetachShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDetachShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDetachShader)
}
var _ = atom.Atom(&GlDispatchCompute{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDispatchCompute.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDispatchCompute().
func (ϟa *GlDispatchCompute) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDispatchCompute().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDispatchCompute) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.NumGroupsX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumGroupsY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.NumGroupsZ.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDispatchCompute)
}
var _ = atom.Atom(&GlDispatchComputeIndirect{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDispatchComputeIndirect.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDispatchComputeIndirect().
func (ϟa *GlDispatchComputeIndirect) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDispatchComputeIndirect().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDispatchComputeIndirect) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Indirect.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDispatchComputeIndirect)
}
var _ = atom.Atom(&GlGenProgramPipelines{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenProgramPipelines.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenProgramPipelines().
func (ϟa *GlGenProgramPipelines) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Pipelines.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.N), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenProgramPipelines().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenProgramPipelines) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pipelines.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenProgramPipelines)
}
var _ = atom.Atom(&GlGetActiveAttrib{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetActiveAttrib.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetActiveAttrib().
func (ϟa *GlGetActiveAttrib) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferSize) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
p := ctx.Instances.Programs.Get(ϟa.Program)
if !(p.OnAccess(ϟs).ActiveAttributes.Contains(ϟa.Index)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferSize, ϟa.BufferBytesWritten, ϟa.Name); ϟerr != nil {
return ϟerr
}
ϟa.VectorCount.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ϟa.VectorCount.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)), ϟa, ϟs, ϟd, ϟb)
ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLenum(ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetActiveAttrib().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetActiveAttrib) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufferSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufferBytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.VectorCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Type.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetActiveAttrib)
}
var _ = atom.Atom(&GlGetActiveUniform{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetActiveUniform.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetActiveUniform().
func (ϟa *GlGetActiveUniform) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferSize) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
p := ctx.Instances.Programs.Get(ϟa.Program)
if !(p.OnAccess(ϟs).ActiveUniforms.Contains(ϟa.Index)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferSize, ϟa.BufferBytesWritten, ϟa.Name); ϟerr != nil {
return ϟerr
}
ϟa.VectorCount.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(ϟa.VectorCount.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)), ϟa, ϟs, ϟd, ϟb)
ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLenum(ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetActiveUniform().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetActiveUniform) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufferSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufferBytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.VectorCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Type.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetActiveUniform)
}
var _ = atom.Atom(&GlGetActiveUniformBlockName{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetActiveUniformBlockName.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetActiveUniformBlockName().
func (ϟa *GlGetActiveUniformBlockName) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferSize, ϟa.BufferBytesWritten, ϟa.Name); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetActiveUniformBlockName().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetActiveUniformBlockName) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.UniformBlockIndex.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufferBytesWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetActiveUniformBlockName)
}
var _ = atom.Atom(&GlGetActiveUniformBlockiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetActiveUniformBlockiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetActiveUniformBlockiv().
func (ϟa *GlGetActiveUniformBlockiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.ParameterName {
case GLenum_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, GLenum_GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, GLenum_GL_UNIFORM_BLOCK_BINDING, GLenum_GL_UNIFORM_BLOCK_DATA_SIZE, GLenum_GL_UNIFORM_BLOCK_NAME_LENGTH, GLenum_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, GLenum_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ParameterName); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Parameters.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Parameters.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetActiveUniformBlockiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetActiveUniformBlockiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.UniformBlockIndex.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ParameterName))
ϟb.Push(ϟa.Parameters.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetActiveUniformBlockiv)
}
var _ = atom.Atom(&GlGetActiveUniformsiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetActiveUniformsiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetActiveUniformsiv().
func (ϟa *GlGetActiveUniformsiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.ParameterName {
case GLenum_GL_UNIFORM_ARRAY_STRIDE, GLenum_GL_UNIFORM_BLOCK_INDEX, GLenum_GL_UNIFORM_IS_ROW_MAJOR, GLenum_GL_UNIFORM_MATRIX_STRIDE, GLenum_GL_UNIFORM_NAME_LENGTH, GLenum_GL_UNIFORM_OFFSET, GLenum_GL_UNIFORM_SIZE, GLenum_GL_UNIFORM_TYPE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ParameterName); ϟerr != nil {
return ϟerr
}
}
ϟa.UniformIndices.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.UniformCount), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Parameters.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.UniformCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetActiveUniformsiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetActiveUniformsiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.UniformCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.UniformIndices.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.ParameterName))
ϟb.Push(ϟa.Parameters.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetActiveUniformsiv)
}
var _ = atom.Atom(&GlGetAttachedShaders{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetAttachedShaders.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetAttachedShaders().
func (ϟa *GlGetAttachedShaders) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferLength) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
p := ctx.Instances.Programs.Get(ϟa.Program)
l, ϟerr := subMin(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, int32(ϟa.BufferLength), int32(len(p.OnAccess(ϟs).Shaders)))
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.ShadersLengthWritten) != (GLsizeiᵖ{}) {
ϟa.ShadersLengthWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLsizei(l), ϟa, ϟs, ϟd, ϟb)
}
s := ϟa.Shaders.Slice(uint64(int32(0)), uint64(l), ϟs)
{
i := int32(0)
for _, v := range p.OnAccess(ϟs).Shaders {
if (i) < (l) {
s.Index(uint64(i), ϟs).Write(ϟctx, v, ϟa, ϟs, ϟd, ϟb)
}
i++
}
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetAttachedShaders().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetAttachedShaders) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ShadersLengthWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Shaders.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetAttachedShaders)
}
var _ = atom.Atom(&GlGetAttribLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetAttribLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetAttribLocation().
// Upon returning the glGetAttribLocation() return value will be stored on the stack.
func (ϟa *GlGetAttribLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetAttribLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetAttribLocation() return value will be stored on the stack.
func (ϟa *GlGetAttribLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetAttribLocation)
}
var _ = atom.Atom(&GlGetFragDataLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFragDataLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFragDataLocation().
// Upon returning the glGetFragDataLocation() return value will be stored on the stack.
func (ϟa *GlGetFragDataLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFragDataLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetFragDataLocation() return value will be stored on the stack.
func (ϟa *GlGetFragDataLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetFragDataLocation)
}
var _ = atom.Atom(&GlGetProgramBinary{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramBinary.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramBinary().
func (ϟa *GlGetProgramBinary) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetProgramBinary(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.BufSize, ϟa.Length, ϟa.BinaryFormat, ϟa.Binary); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramBinary().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramBinary) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BinaryFormat.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Binary.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramBinary)
}
var _ = atom.Atom(&GlGetProgramInfoLog{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramInfoLog.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramInfoLog().
func (ϟa *GlGetProgramInfoLog) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferLength) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferLength, ϟa.StringLengthWritten, ϟa.Info); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramInfoLog().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramInfoLog) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.StringLengthWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Info.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramInfoLog)
}
var _ = atom.Atom(&GlGetProgramInterfaceiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramInterfaceiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramInterfaceiv().
func (ϟa *GlGetProgramInterfaceiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.ProgramInterface {
case GLenum_GL_ATOMIC_COUNTER_BUFFER, GLenum_GL_BUFFER_VARIABLE, GLenum_GL_PROGRAM_INPUT, GLenum_GL_PROGRAM_OUTPUT, GLenum_GL_SHADER_STORAGE_BLOCK, GLenum_GL_TRANSFORM_FEEDBACK_BUFFER, GLenum_GL_TRANSFORM_FEEDBACK_VARYING, GLenum_GL_UNIFORM, GLenum_GL_UNIFORM_BLOCK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ProgramInterface); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Pname {
case GLenum_GL_ACTIVE_RESOURCES, GLenum_GL_MAX_NAME_LENGTH, GLenum_GL_MAX_NUM_ACTIVE_VARIABLES:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramInterfaceiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramInterfaceiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramInterfaceiv)
}
var _ = atom.Atom(&GlGetProgramPipelineInfoLog{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramPipelineInfoLog.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramPipelineInfoLog().
func (ϟa *GlGetProgramPipelineInfoLog) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufSize, ϟa.Length, ϟa.InfoLog); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramPipelineInfoLog().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramPipelineInfoLog) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.InfoLog.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramPipelineInfoLog)
}
var _ = atom.Atom(&GlGetProgramPipelineiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramPipelineiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramPipelineiv().
func (ϟa *GlGetProgramPipelineiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Pname {
case GLenum_GL_ACTIVE_PROGRAM, GLenum_GL_COMPUTE_SHADER, GLenum_GL_FRAGMENT_SHADER, GLenum_GL_INFO_LOG_LENGTH, GLenum_GL_VALIDATE_STATUS, GLenum_GL_VERTEX_SHADER:
case GLenum_GL_GEOMETRY_SHADER, GLenum_GL_TESS_CONTROL_SHADER, GLenum_GL_TESS_EVALUATION_SHADER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramPipelineiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramPipelineiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramPipelineiv)
}
var _ = atom.Atom(&GlGetProgramResourceIndex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourceIndex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourceIndex().
// Upon returning the glGetProgramResourceIndex() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceIndex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.ProgramInterface {
case GLenum_GL_BUFFER_VARIABLE, GLenum_GL_PROGRAM_INPUT, GLenum_GL_PROGRAM_OUTPUT, GLenum_GL_SHADER_STORAGE_BLOCK, GLenum_GL_TRANSFORM_FEEDBACK_VARYING, GLenum_GL_UNIFORM, GLenum_GL_UNIFORM_BLOCK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ProgramInterface); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourceIndex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetProgramResourceIndex() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceIndex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetProgramResourceIndex)
}
var _ = atom.Atom(&GlGetProgramResourceLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourceLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourceLocation().
// Upon returning the glGetProgramResourceLocation() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.ProgramInterface {
case GLenum_GL_PROGRAM_INPUT, GLenum_GL_PROGRAM_OUTPUT, GLenum_GL_TRANSFORM_FEEDBACK_BUFFER, GLenum_GL_UNIFORM:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ProgramInterface); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourceLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetProgramResourceLocation() return value will be stored on the stack.
func (ϟa *GlGetProgramResourceLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetProgramResourceLocation)
}
var _ = atom.Atom(&GlGetProgramResourceName{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourceName.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourceName().
func (ϟa *GlGetProgramResourceName) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.ProgramInterface {
case GLenum_GL_BUFFER_VARIABLE, GLenum_GL_PROGRAM_INPUT, GLenum_GL_PROGRAM_OUTPUT, GLenum_GL_SHADER_STORAGE_BLOCK, GLenum_GL_TRANSFORM_FEEDBACK_VARYING, GLenum_GL_UNIFORM, GLenum_GL_UNIFORM_BLOCK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ProgramInterface); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufSize, ϟa.Length, ϟa.Name); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourceName().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramResourceName) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramResourceName)
}
var _ = atom.Atom(&GlGetProgramResourceiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramResourceiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramResourceiv().
func (ϟa *GlGetProgramResourceiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.ProgramInterface {
case GLenum_GL_ATOMIC_COUNTER_BUFFER, GLenum_GL_BUFFER_VARIABLE, GLenum_GL_PROGRAM_INPUT, GLenum_GL_PROGRAM_OUTPUT, GLenum_GL_SHADER_STORAGE_BLOCK, GLenum_GL_TRANSFORM_FEEDBACK_BUFFER, GLenum_GL_TRANSFORM_FEEDBACK_VARYING, GLenum_GL_UNIFORM, GLenum_GL_UNIFORM_BLOCK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ProgramInterface); ϟerr != nil {
return ϟerr
}
}
ϟa.Props.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.PropCount), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Length) != (GLsizeiᵖ{}) {
l := GLsizei(ϟa.Length.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ϟa.Length.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, l, ϟa, ϟs, ϟd, ϟb)
ϟa.Params.Slice(uint64(GLsizei(int32(0))), uint64(l), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
ϟa.Params.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.BufSize), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramResourceiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramResourceiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.ProgramInterface))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.PropCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Props.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramResourceiv)
}
var _ = atom.Atom(&GlGetProgramiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetProgramiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetProgramiv().
func (ϟa *GlGetProgramiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Parameter {
case GLenum_GL_ACTIVE_ATTRIBUTES, GLenum_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GLenum_GL_ACTIVE_UNIFORMS, GLenum_GL_ACTIVE_UNIFORM_MAX_LENGTH, GLenum_GL_ATTACHED_SHADERS, GLenum_GL_DELETE_STATUS, GLenum_GL_INFO_LOG_LENGTH, GLenum_GL_LINK_STATUS, GLenum_GL_VALIDATE_STATUS:
case GLenum_GL_ACTIVE_UNIFORM_BLOCKS, GLenum_GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, GLenum_GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GLenum_GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GLenum_GL_TRANSFORM_FEEDBACK_VARYINGS, GLenum_GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_PROGRAM_BINARY_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, GLenum_GL_COMPUTE_WORK_GROUP_SIZE, GLenum_GL_PROGRAM_SEPARABLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_GEOMETRY_INPUT_TYPE, GLenum_GL_GEOMETRY_OUTPUT_TYPE, GLenum_GL_GEOMETRY_VERTICES_OUT, GLenum_GL_GEOMETRY_SHADER_INVOCATIONS, GLenum_GL_TESS_CONTROL_OUTPUT_VERTICES, GLenum_GL_TESS_GEN_MODE, GLenum_GL_TESS_GEN_POINT_MODE, GLenum_GL_TESS_GEN_SPACING, GLenum_GL_TESS_GEN_VERTEX_ORDER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetProgramiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetProgramiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetProgramiv)
}
var _ = atom.Atom(&GlGetShaderInfoLog{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetShaderInfoLog.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetShaderInfoLog().
func (ϟa *GlGetShaderInfoLog) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferLength) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferLength, ϟa.StringLengthWritten, ϟa.Info); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetShaderInfoLog().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetShaderInfoLog) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.StringLengthWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Info.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetShaderInfoLog)
}
var _ = atom.Atom(&GlGetShaderPrecisionFormat{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetShaderPrecisionFormat.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetShaderPrecisionFormat().
func (ϟa *GlGetShaderPrecisionFormat) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.ShaderType {
case GLenum_GL_FRAGMENT_SHADER, GLenum_GL_VERTEX_SHADER:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.ShaderType); ϟerr != nil {
return ϟerr
}
}
switch ϟa.PrecisionType {
case GLenum_GL_HIGH_FLOAT, GLenum_GL_HIGH_INT, GLenum_GL_LOW_FLOAT, GLenum_GL_LOW_INT, GLenum_GL_MEDIUM_FLOAT, GLenum_GL_MEDIUM_INT:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.PrecisionType); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Range.Slice(uint64(0), uint64(2), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
ϟa.Precision.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Precision.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetShaderPrecisionFormat().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetShaderPrecisionFormat) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.ShaderType))
ϟb.Push(value.U32(ϟa.PrecisionType))
ϟb.Push(ϟa.Range.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Precision.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetShaderPrecisionFormat)
}
var _ = atom.Atom(&GlGetShaderSource{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetShaderSource.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetShaderSource().
func (ϟa *GlGetShaderSource) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
if (ϟa.BufferLength) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferLength, ϟa.StringLengthWritten, ϟa.Source); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetShaderSource().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetShaderSource) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufferLength.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.StringLengthWritten.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Source.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetShaderSource)
}
var _ = atom.Atom(&GlGetShaderiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetShaderiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetShaderiv().
func (ϟa *GlGetShaderiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Parameter {
case GLenum_GL_COMPILE_STATUS, GLenum_GL_DELETE_STATUS, GLenum_GL_INFO_LOG_LENGTH, GLenum_GL_SHADER_SOURCE_LENGTH, GLenum_GL_SHADER_TYPE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Shaders.Get(ϟa.Shader)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, func() (result GLint) {
switch ϟa.Parameter {
case GLenum_GL_SHADER_TYPE:
return GLint(s.OnAccess(ϟs).Type)
case GLenum_GL_DELETE_STATUS:
return func() (result GLint) {
switch s.OnAccess(ϟs).DeleteStatus {
case true:
return GLint(int32(1))
case false:
return GLint(int32(0))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", s.OnAccess(ϟs).DeleteStatus, ϟa))
return result
}
}()
case GLenum_GL_COMPILE_STATUS:
return func() (result GLint) {
switch s.OnAccess(ϟs).Compiled {
case true:
return GLint(int32(1))
case false:
return GLint(int32(0))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", s.OnAccess(ϟs).Compiled, ϟa))
return result
}
}()
case GLenum_GL_INFO_LOG_LENGTH:
return GLint(int32(s.OnAccess(ϟs).InfoLog.Count))
case GLenum_GL_SHADER_SOURCE_LENGTH:
return GLint(int32(len(s.OnAccess(ϟs).Source)))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetShaderiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetShaderiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetShaderiv)
}
var _ = atom.Atom(&GlGetUniformBlockIndex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformBlockIndex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformBlockIndex().
// Upon returning the glGetUniformBlockIndex() return value will be stored on the stack.
func (ϟa *GlGetUniformBlockIndex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformBlockIndex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetUniformBlockIndex() return value will be stored on the stack.
func (ϟa *GlGetUniformBlockIndex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.UniformBlockName))
ϟb.Call(funcInfoGlGetUniformBlockIndex)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(4))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlGetUniformIndices{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformIndices.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformIndices().
func (ϟa *GlGetUniformIndices) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
names := ϟa.UniformNames.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.UniformCount), ϟs)
for i := GLsizei(int32(0)); i < ϟa.UniformCount; i++ {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(names.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.UniformIndices.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.UniformCount), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformIndices().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetUniformIndices) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.UniformCount.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.UniformNames.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.UniformIndices.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetUniformIndices)
}
var _ = atom.Atom(&GlGetUniformLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformLocation().
// Upon returning the glGetUniformLocation() return value will be stored on the stack.
func (ϟa *GlGetUniformLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetUniformLocation() return value will be stored on the stack.
func (ϟa *GlGetUniformLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetUniformLocation)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(4))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlGetUniformfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformfv().
func (ϟa *GlGetUniformfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetUniformv_GLfloat__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetUniformfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetUniformfv)
}
var _ = atom.Atom(&GlGetUniformiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformiv().
func (ϟa *GlGetUniformiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetUniformv_GLint__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetUniformiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetUniformiv)
}
var _ = atom.Atom(&GlGetUniformuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetUniformuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetUniformuiv().
func (ϟa *GlGetUniformuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetUniformv_GLuint__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetUniformuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetUniformuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetUniformuiv)
}
var _ = atom.Atom(&GlGetnUniformfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformfv().
func (ϟa *GlGetnUniformfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformfv_GLfloat__P(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformfv)
}
var _ = atom.Atom(&GlGetnUniformiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformiv().
func (ϟa *GlGetnUniformiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformiv)
}
var _ = atom.Atom(&GlGetnUniformuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetnUniformuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetnUniformuiv().
func (ϟa *GlGetnUniformuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetnUniformuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.BufSize, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetnUniformuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetnUniformuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetnUniformuiv)
}
var _ = atom.Atom(&GlIsProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsProgram().
// Upon returning the glIsProgram() return value will be stored on the stack.
func (ϟa *GlIsProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Programs.Contains(ϟa.Program) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsProgram() return value will be stored on the stack.
func (ϟa *GlIsProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsProgram)
}
var _ = atom.Atom(&GlIsProgramPipeline{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsProgramPipeline.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsProgramPipeline().
// Upon returning the glIsProgramPipeline() return value will be stored on the stack.
func (ϟa *GlIsProgramPipeline) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsProgramPipeline().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsProgramPipeline() return value will be stored on the stack.
func (ϟa *GlIsProgramPipeline) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsProgramPipeline)
}
var _ = atom.Atom(&GlIsShader{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsShader.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsShader().
// Upon returning the glIsShader() return value will be stored on the stack.
func (ϟa *GlIsShader) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Shaders.Contains(ϟa.Shader) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsShader().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsShader() return value will be stored on the stack.
func (ϟa *GlIsShader) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsShader)
}
var _ = atom.Atom(&GlLinkProgram{}) // interface compliance check
func (ϟa *GlLinkProgram) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subApplyProgramInfoExtra(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, (externs{ϟctx, ϟa, ϟs, ϟd, ϟb}.GetProgramInfoExtra(ϟa.Program))); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLinkProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLinkProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlLinkProgram)
}
var _ = atom.Atom(&GlMemoryBarrier{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMemoryBarrier.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMemoryBarrier().
func (ϟa *GlMemoryBarrier) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Barriers, (GLbitfield_GL_ALL_BARRIER_BITS)|((GLbitfield_GL_ATOMIC_COUNTER_BARRIER_BIT)|((GLbitfield_GL_BUFFER_UPDATE_BARRIER_BIT)|((GLbitfield_GL_COMMAND_BARRIER_BIT)|((GLbitfield_GL_ELEMENT_ARRAY_BARRIER_BIT)|((GLbitfield_GL_FRAMEBUFFER_BARRIER_BIT)|((GLbitfield_GL_PIXEL_BUFFER_BARRIER_BIT)|((GLbitfield_GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)|((GLbitfield_GL_SHADER_STORAGE_BARRIER_BIT)|((GLbitfield_GL_TEXTURE_FETCH_BARRIER_BIT)|((GLbitfield_GL_TEXTURE_UPDATE_BARRIER_BIT)|((GLbitfield_GL_TRANSFORM_FEEDBACK_BARRIER_BIT)|((GLbitfield_GL_UNIFORM_BARRIER_BIT)|(GLbitfield_GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT)))))))))))))); ϟerr != nil {
return ϟerr
}
if (GLbitfield_GL_ALL_BARRIER_BITS)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_ATOMIC_COUNTER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_BUFFER_UPDATE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_COMMAND_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_ELEMENT_ARRAY_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_FRAMEBUFFER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_PIXEL_BUFFER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_SHADER_STORAGE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TEXTURE_FETCH_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TEXTURE_UPDATE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TRANSFORM_FEEDBACK_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_UNIFORM_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMemoryBarrier().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMemoryBarrier) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Barriers))
ϟb.Call(funcInfoGlMemoryBarrier)
}
var _ = atom.Atom(&GlMemoryBarrierByRegion{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMemoryBarrierByRegion.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMemoryBarrierByRegion().
func (ϟa *GlMemoryBarrierByRegion) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Barriers, (GLbitfield_GL_ALL_BARRIER_BITS)|((GLbitfield_GL_ATOMIC_COUNTER_BARRIER_BIT)|((GLbitfield_GL_BUFFER_UPDATE_BARRIER_BIT)|((GLbitfield_GL_COMMAND_BARRIER_BIT)|((GLbitfield_GL_ELEMENT_ARRAY_BARRIER_BIT)|((GLbitfield_GL_FRAMEBUFFER_BARRIER_BIT)|((GLbitfield_GL_PIXEL_BUFFER_BARRIER_BIT)|((GLbitfield_GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)|((GLbitfield_GL_SHADER_STORAGE_BARRIER_BIT)|((GLbitfield_GL_TEXTURE_FETCH_BARRIER_BIT)|((GLbitfield_GL_TEXTURE_UPDATE_BARRIER_BIT)|((GLbitfield_GL_TRANSFORM_FEEDBACK_BARRIER_BIT)|((GLbitfield_GL_UNIFORM_BARRIER_BIT)|(GLbitfield_GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT)))))))))))))); ϟerr != nil {
return ϟerr
}
if (GLbitfield_GL_ALL_BARRIER_BITS)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_ATOMIC_COUNTER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_BUFFER_UPDATE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_COMMAND_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_ELEMENT_ARRAY_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_FRAMEBUFFER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_PIXEL_BUFFER_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_SHADER_STORAGE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TEXTURE_FETCH_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TEXTURE_UPDATE_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_TRANSFORM_FEEDBACK_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_UNIFORM_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if (GLbitfield_GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT)&(ϟa.Barriers) != 0 {
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMemoryBarrierByRegion().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMemoryBarrierByRegion) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Barriers))
ϟb.Call(funcInfoGlMemoryBarrierByRegion)
}
var _ = atom.Atom(&GlProgramBinary{}) // interface compliance check
func (ϟa *GlProgramBinary) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subProgramBinary(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.BinaryFormat, ϟa.Binary, ϟa.Length); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramBinary().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramBinary) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.BinaryFormat))
ϟb.Push(ϟa.Binary.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramBinary)
}
var _ = atom.Atom(&GlProgramParameteri{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramParameteri.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramParameteri().
func (ϟa *GlProgramParameteri) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramParameteri(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Pname, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramParameteri().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramParameteri) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramParameteri)
}
var _ = atom.Atom(&GlProgramUniform1f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1f().
func (ϟa *GlProgramUniform1f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1f)
}
var _ = atom.Atom(&GlProgramUniform1fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1fv().
func (ϟa *GlProgramUniform1fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1fv)
}
var _ = atom.Atom(&GlProgramUniform1i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1i().
func (ϟa *GlProgramUniform1i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1i)
}
var _ = atom.Atom(&GlProgramUniform1iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1iv().
func (ϟa *GlProgramUniform1iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1iv)
}
var _ = atom.Atom(&GlProgramUniform1ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1ui().
func (ϟa *GlProgramUniform1ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1ui)
}
var _ = atom.Atom(&GlProgramUniform1uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform1uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform1uiv().
func (ϟa *GlProgramUniform1uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform1uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform1uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform1uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform1uiv)
}
var _ = atom.Atom(&GlProgramUniform2f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2f().
func (ϟa *GlProgramUniform2f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2f)
}
var _ = atom.Atom(&GlProgramUniform2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2fv().
func (ϟa *GlProgramUniform2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2fv)
}
var _ = atom.Atom(&GlProgramUniform2i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2i().
func (ϟa *GlProgramUniform2i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2i)
}
var _ = atom.Atom(&GlProgramUniform2iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2iv().
func (ϟa *GlProgramUniform2iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2iv)
}
var _ = atom.Atom(&GlProgramUniform2ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2ui().
func (ϟa *GlProgramUniform2ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2ui)
}
var _ = atom.Atom(&GlProgramUniform2uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform2uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform2uiv().
func (ϟa *GlProgramUniform2uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform2uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform2uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform2uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform2uiv)
}
var _ = atom.Atom(&GlProgramUniform3f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3f().
func (ϟa *GlProgramUniform3f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3f)
}
var _ = atom.Atom(&GlProgramUniform3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3fv().
func (ϟa *GlProgramUniform3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3fv)
}
var _ = atom.Atom(&GlProgramUniform3i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3i().
func (ϟa *GlProgramUniform3i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3i)
}
var _ = atom.Atom(&GlProgramUniform3iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3iv().
func (ϟa *GlProgramUniform3iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3iv)
}
var _ = atom.Atom(&GlProgramUniform3ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3ui().
func (ϟa *GlProgramUniform3ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3ui)
}
var _ = atom.Atom(&GlProgramUniform3uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform3uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform3uiv().
func (ϟa *GlProgramUniform3uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform3uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform3uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform3uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform3uiv)
}
var _ = atom.Atom(&GlProgramUniform4f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4f().
func (ϟa *GlProgramUniform4f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4f)
}
var _ = atom.Atom(&GlProgramUniform4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4fv().
func (ϟa *GlProgramUniform4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4fv)
}
var _ = atom.Atom(&GlProgramUniform4i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4i().
func (ϟa *GlProgramUniform4i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4i)
}
var _ = atom.Atom(&GlProgramUniform4iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4iv().
func (ϟa *GlProgramUniform4iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4iv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4iv)
}
var _ = atom.Atom(&GlProgramUniform4ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4ui().
func (ϟa *GlProgramUniform4ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4ui(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4ui)
}
var _ = atom.Atom(&GlProgramUniform4uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniform4uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniform4uiv().
func (ϟa *GlProgramUniform4uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniform4uiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniform4uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniform4uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniform4uiv)
}
var _ = atom.Atom(&GlProgramUniformMatrix2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2fv().
func (ϟa *GlProgramUniformMatrix2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix2x3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2x3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2x3fv().
func (ϟa *GlProgramUniformMatrix2x3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2x3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2x3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2x3fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix2x4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix2x4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix2x4fv().
func (ϟa *GlProgramUniformMatrix2x4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix2x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix2x4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix2x4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix2x4fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3fv().
func (ϟa *GlProgramUniformMatrix3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix3x2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3x2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3x2fv().
func (ϟa *GlProgramUniformMatrix3x2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3x2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3x2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3x2fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix3x4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix3x4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix3x4fv().
func (ϟa *GlProgramUniformMatrix3x4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix3x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix3x4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix3x4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix3x4fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4fv().
func (ϟa *GlProgramUniformMatrix4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix4x2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4x2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4x2fv().
func (ϟa *GlProgramUniformMatrix4x2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4x2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4x2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4x2fv)
}
var _ = atom.Atom(&GlProgramUniformMatrix4x3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glProgramUniformMatrix4x3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glProgramUniformMatrix4x3fv().
func (ϟa *GlProgramUniformMatrix4x3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subProgramUniformMatrix4x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Program, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glProgramUniformMatrix4x3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlProgramUniformMatrix4x3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlProgramUniformMatrix4x3fv)
}
var _ = atom.Atom(&GlReleaseShaderCompiler{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glReleaseShaderCompiler.
// If ϟb is not nil, Mutate also emits the replay instructions to call glReleaseShaderCompiler().
func (ϟa *GlReleaseShaderCompiler) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glReleaseShaderCompiler().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlReleaseShaderCompiler) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlReleaseShaderCompiler)
}
var _ = atom.Atom(&GlShaderBinary{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glShaderBinary.
// If ϟb is not nil, Mutate also emits the replay instructions to call glShaderBinary().
func (ϟa *GlShaderBinary) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.BinaryFormat {
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BinaryFormat); ϟerr != nil {
return ϟerr
}
}
ϟa.Shaders.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
ϟa.Binary.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.BinarySize), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glShaderBinary().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlShaderBinary) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Shaders.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.BinaryFormat))
ϟb.Push(ϟa.Binary.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BinarySize.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlShaderBinary)
}
var _ = atom.Atom(&GlShaderSource{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glShaderSource.
// If ϟb is not nil, Mutate also emits the replay instructions to call glShaderSource().
func (ϟa *GlShaderSource) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
sources := ϟa.Source.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckShader(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Shader); ϟerr != nil {
return ϟerr
}
s := ctx.Instances.Shaders.Get(ϟa.Shader)
s.OnAccess(ϟs).Source = ""
if (ϟa.Length) == (GLintᶜᵖ{}) {
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
s.OnAccess(ϟs).Source += strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(sources.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
} else {
lengths := ϟa.Length.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
str := func() (result string) {
switch (lengths.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)) < (GLint(int32(0))) {
case true:
return strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(sources.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
case false:
return string(gfxapi.CharToBytes(Charᵖ(sources.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).Slice(uint64(GLint(int32(0))), uint64(lengths.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (lengths.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)) < (GLint(int32(0))), ϟa))
return result
}
}()
s.OnAccess(ϟs).Source += str
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glShaderSource().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlShaderSource) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Source.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlShaderSource)
}
var _ = atom.Atom(&GlUniform1f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1f().
func (ϟa *GlUniform1f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeGLfloatˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_GLfloat__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1f)
}
var _ = atom.Atom(&GlUniform1fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1fv().
func (ϟa *GlUniform1fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Values.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_GLfloat__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1fv)
}
var _ = atom.Atom(&GlUniform1i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1i().
func (ϟa *GlUniform1i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeGLintˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_GLint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1i)
}
var _ = atom.Atom(&GlUniform1iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1iv().
func (ϟa *GlUniform1iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Values.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_GLint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1iv)
}
var _ = atom.Atom(&GlUniform1ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1ui().
func (ϟa *GlUniform1ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeGLuintˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value0, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_GLuint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1ui)
}
var _ = atom.Atom(&GlUniform1uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform1uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform1uiv().
func (ϟa *GlUniform1uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Values.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_GLuint__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform1uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform1uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform1uiv)
}
var _ = atom.Atom(&GlUniform2f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2f().
func (ϟa *GlUniform2f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec2fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2f{Elements: [2]GLfloat{ϟa.Value0, ϟa.Value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2f)
}
var _ = atom.Atom(&GlUniform2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2fv().
func (ϟa *GlUniform2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec2fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2fv)
}
var _ = atom.Atom(&GlUniform2i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2i().
func (ϟa *GlUniform2i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec2iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2i{Elements: [2]GLint{ϟa.Value0, ϟa.Value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec2i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2i)
}
var _ = atom.Atom(&GlUniform2iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2iv().
func (ϟa *GlUniform2iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec2iᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec2i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2iv)
}
var _ = atom.Atom(&GlUniform2ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2ui().
func (ϟa *GlUniform2ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec2uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec2u{Elements: [2]GLuint{ϟa.Value0, ϟa.Value1}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec2u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2ui)
}
var _ = atom.Atom(&GlUniform2uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform2uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform2uiv().
func (ϟa *GlUniform2uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec2uᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec2u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform2uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform2uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform2uiv)
}
var _ = atom.Atom(&GlUniform3f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3f().
func (ϟa *GlUniform3f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec3fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3f{Elements: [3]GLfloat{ϟa.Value0, ϟa.Value1, ϟa.Value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3f)
}
var _ = atom.Atom(&GlUniform3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3fv().
func (ϟa *GlUniform3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec3fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3fv)
}
var _ = atom.Atom(&GlUniform3i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3i().
func (ϟa *GlUniform3i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec3iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3i{Elements: [3]GLint{ϟa.Value0, ϟa.Value1, ϟa.Value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec3i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3i)
}
var _ = atom.Atom(&GlUniform3iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3iv().
func (ϟa *GlUniform3iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec3iᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec3i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3iv)
}
var _ = atom.Atom(&GlUniform3ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3ui().
func (ϟa *GlUniform3ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec3uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec3u{Elements: [3]GLuint{ϟa.Value0, ϟa.Value1, ϟa.Value2}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec3u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3ui)
}
var _ = atom.Atom(&GlUniform3uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform3uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform3uiv().
func (ϟa *GlUniform3uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec3uᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec3u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform3uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform3uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform3uiv)
}
var _ = atom.Atom(&GlUniform4f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4f().
func (ϟa *GlUniform4f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec4fˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4f{Elements: [4]GLfloat{ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4f)
}
var _ = atom.Atom(&GlUniform4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4fv().
func (ϟa *GlUniform4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec4fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_FLOAT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4fv)
}
var _ = atom.Atom(&GlUniform4i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4i().
func (ϟa *GlUniform4i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec4iˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4i{Elements: [4]GLint{ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec4i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4i)
}
var _ = atom.Atom(&GlUniform4iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4iv().
func (ϟa *GlUniform4iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec4iᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec4i__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_INT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4iv)
}
var _ = atom.Atom(&GlUniform4ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4ui().
func (ϟa *GlUniform4ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := MakeVec4uˢ(uint64(1), ϟs)
v.Index(uint64(0), ϟs).Write(ϟctx, Vec4u{Elements: [4]GLuint{ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3}}, ϟa, ϟs, ϟd, ϟb)
if ϟerr := subUniformv_Vec4u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4ui)
}
var _ = atom.Atom(&GlUniform4uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniform4uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniform4uiv().
func (ϟa *GlUniform4uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Vec4uᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformv_Vec4u__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, v, GLenum_GL_UNSIGNED_INT_VEC4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniform4uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniform4uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniform4uiv)
}
var _ = atom.Atom(&GlUniformBlockBinding{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformBlockBinding.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformBlockBinding().
func (ϟa *GlUniformBlockBinding) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformBlockBinding().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformBlockBinding) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
if key, remap := ϟa.UniformBlockIndex.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.UniformBlockIndex.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.UniformBlockBinding.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformBlockBinding)
}
var _ = atom.Atom(&GlUniformMatrix2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix2fv().
func (ϟa *GlUniformMatrix2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Mat2fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformMatrixv_Mat2f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Transpose, v, GLenum_GL_FLOAT_MAT2); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix2fv)
}
var _ = atom.Atom(&GlUniformMatrix2x3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix2x3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix2x3fv().
func (ϟa *GlUniformMatrix2x3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix2x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix2x3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix2x3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix2x3fv)
}
var _ = atom.Atom(&GlUniformMatrix2x4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix2x4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix2x4fv().
func (ϟa *GlUniformMatrix2x4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix2x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix2x4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix2x4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix2x4fv)
}
var _ = atom.Atom(&GlUniformMatrix3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix3fv().
func (ϟa *GlUniformMatrix3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Mat3fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformMatrixv_Mat3f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Transpose, v, GLenum_GL_FLOAT_MAT3); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix3fv)
}
var _ = atom.Atom(&GlUniformMatrix3x2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix3x2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix3x2fv().
func (ϟa *GlUniformMatrix3x2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix3x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix3x2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix3x2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix3x2fv)
}
var _ = atom.Atom(&GlUniformMatrix3x4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix3x4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix3x4fv().
func (ϟa *GlUniformMatrix3x4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix3x4fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix3x4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix3x4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix3x4fv)
}
var _ = atom.Atom(&GlUniformMatrix4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix4fv().
func (ϟa *GlUniformMatrix4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := Mat4fᵖ(ϟa.Values).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
if ϟerr := subUniformMatrixv_Mat4f__S(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Transpose, v, GLenum_GL_FLOAT_MAT4); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix4fv)
}
var _ = atom.Atom(&GlUniformMatrix4x2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix4x2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix4x2fv().
func (ϟa *GlUniformMatrix4x2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix4x2fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix4x2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix4x2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix4x2fv)
}
var _ = atom.Atom(&GlUniformMatrix4x3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUniformMatrix4x3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUniformMatrix4x3fv().
func (ϟa *GlUniformMatrix4x3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subUniformMatrix4x3fv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, ϟa.Count, ϟa.Transpose, ϟa.Values); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUniformMatrix4x3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUniformMatrix4x3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Int32, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Transpose.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlUniformMatrix4x3fv)
}
var _ = atom.Atom(&GlUseProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUseProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUseProgram().
func (ϟa *GlUseProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Program) != (ProgramId(uint32(0))) {
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
}
if ((ϟa.Program) == (ProgramId(uint32(0)))) || (ctx.Instances.Programs.Contains(ϟa.Program)) {
if (ctx.BoundProgram) != (ϟa.Program) {
if ϟerr := subReapProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ctx.BoundProgram); ϟerr != nil {
return ϟerr
}
}
ctx.BoundProgram = ϟa.Program
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUseProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUseProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlUseProgram)
}
var _ = atom.Atom(&GlUseProgramStages{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glUseProgramStages.
// If ϟb is not nil, Mutate also emits the replay instructions to call glUseProgramStages().
func (ϟa *GlUseProgramStages) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSupportsBits(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Stages, (GLbitfield_GL_ALL_SHADER_BITS)|((GLbitfield_GL_COMPUTE_SHADER_BIT)|((GLbitfield_GL_FRAGMENT_SHADER_BIT)|(GLbitfield_GL_VERTEX_SHADER_BIT)))); ϟerr != nil {
return ϟerr
}
if (GLbitfield_GL_ALL_SHADER_BITS)&(ϟa.Stages) != 0 {
}
if (GLbitfield_GL_COMPUTE_SHADER_BIT)&(ϟa.Stages) != 0 {
}
if (GLbitfield_GL_FRAGMENT_SHADER_BIT)&(ϟa.Stages) != 0 {
}
if (GLbitfield_GL_VERTEX_SHADER_BIT)&(ϟa.Stages) != 0 {
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glUseProgramStages().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlUseProgramStages) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Stages))
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlUseProgramStages)
}
var _ = atom.Atom(&GlValidateProgram{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glValidateProgram.
// If ϟb is not nil, Mutate also emits the replay instructions to call glValidateProgram().
func (ϟa *GlValidateProgram) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckProgram(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Program); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glValidateProgram().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlValidateProgram) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlValidateProgram)
}
var _ = atom.Atom(&GlValidateProgramPipeline{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glValidateProgramPipeline.
// If ϟb is not nil, Mutate also emits the replay instructions to call glValidateProgramPipeline().
func (ϟa *GlValidateProgramPipeline) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glValidateProgramPipeline().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlValidateProgramPipeline) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Pipeline.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlValidateProgramPipeline)
}
var _ = atom.Atom(&GlCullFace{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCullFace.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCullFace().
func (ϟa *GlCullFace) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Mode {
case GLenum_GL_BACK, GLenum_GL_FRONT, GLenum_GL_FRONT_AND_BACK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Mode); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.CullFaceMode = ϟa.Mode
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCullFace().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCullFace) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlCullFace)
}
var _ = atom.Atom(&GlDepthRangef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangef().
func (ϟa *GlDepthRangef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.DepthRange = Vec2f{Elements: [2]GLfloat{ϟa.Near, ϟa.Far}}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Near.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Far.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangef)
}
var _ = atom.Atom(&GlFrontFace{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFrontFace.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFrontFace().
func (ϟa *GlFrontFace) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Orientation {
case GLenum_GL_CCW, GLenum_GL_CW:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Orientation); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.FrontFace = ϟa.Orientation
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFrontFace().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFrontFace) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Orientation))
ϟb.Call(funcInfoGlFrontFace)
}
var _ = atom.Atom(&GlGetMultisamplefv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetMultisamplefv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetMultisamplefv().
func (ϟa *GlGetMultisamplefv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Pname {
case GLenum_GL_SAMPLE_POSITION:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
ϟa.Val.Slice(uint64(0), uint64(2), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetMultisamplefv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetMultisamplefv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Val.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetMultisamplefv)
}
var _ = atom.Atom(&GlLineWidth{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLineWidth.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLineWidth().
func (ϟa *GlLineWidth) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Width) <= (GLfloat(float32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.LineWidth = ϟa.Width
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLineWidth().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLineWidth) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLineWidth)
}
var _ = atom.Atom(&GlMinSampleShading{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMinSampleShading.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMinSampleShading().
func (ϟa *GlMinSampleShading) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subMinSampleShading(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Value); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMinSampleShading().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMinSampleShading) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMinSampleShading)
}
var _ = atom.Atom(&GlPolygonOffset{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPolygonOffset.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPolygonOffset().
func (ϟa *GlPolygonOffset) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.PolygonOffsetUnits = ϟa.Units
ctx.Rasterization.PolygonOffsetFactor = ϟa.ScaleFactor
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPolygonOffset().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPolygonOffset) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.ScaleFactor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Units.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPolygonOffset)
}
var _ = atom.Atom(&GlViewport{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glViewport.
// If ϟb is not nil, Mutate also emits the replay instructions to call glViewport().
func (ϟa *GlViewport) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ((ϟa.Width) < (GLsizei(int32(0)))) || ((ϟa.Height) < (GLsizei(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.Rasterization.Viewport = Rect{X: ϟa.X, Y: ϟa.Y, Width: ϟa.Width, Height: ϟa.Height}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glViewport().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlViewport) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlViewport)
}
var _ = atom.Atom(&GlGetBooleani_v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBooleani_v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBooleani_v().
func (ϟa *GlGetBooleani_v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLboolean(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, true, ϟa.Index, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBooleani_v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBooleani_v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBooleani_v)
}
var _ = atom.Atom(&GlGetBooleanv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetBooleanv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetBooleanv().
func (ϟa *GlGetBooleanv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLboolean(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, false, GLuint(uint32(0)), ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetBooleanv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetBooleanv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetBooleanv)
}
var _ = atom.Atom(&GlGetFloatv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFloatv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFloatv().
func (ϟa *GlGetFloatv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLfloat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, false, GLuint(uint32(0)), ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFloatv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFloatv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFloatv)
}
var _ = atom.Atom(&GlGetInteger64i_v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetInteger64i_v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetInteger64i_v().
func (ϟa *GlGetInteger64i_v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLint64(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, true, ϟa.Index, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetInteger64i_v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetInteger64i_v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetInteger64i_v)
}
var _ = atom.Atom(&GlGetInteger64v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetInteger64v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetInteger64v().
func (ϟa *GlGetInteger64v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetInteger64v(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetInteger64v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetInteger64v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetInteger64v)
}
var _ = atom.Atom(&GlGetIntegeri_v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetIntegeri_v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetIntegeri_v().
func (ϟa *GlGetIntegeri_v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, true, ϟa.Index, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetIntegeri_v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetIntegeri_v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetIntegeri_v)
}
var _ = atom.Atom(&GlGetIntegerv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetIntegerv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetIntegerv().
func (ϟa *GlGetIntegerv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetStateVariable_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param, false, GLuint(uint32(0)), ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetIntegerv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetIntegerv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetIntegerv)
}
var _ = atom.Atom(&GlGetInternalformativ{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetInternalformativ.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetInternalformativ().
func (ϟa *GlGetInternalformativ) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_RENDERBUFFER:
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Internalformat {
case GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R11F_G11F_B10F, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_R8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RG8_SNORM, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB16F, GLenum_GL_RGB16I, GLenum_GL_RGB16UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGB8I, GLenum_GL_RGB8UI, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB9_E5, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8:
case GLenum_GL_STENCIL_INDEX8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Internalformat); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Pname {
case GLenum_GL_NUM_SAMPLE_COUNTS, GLenum_GL_SAMPLES:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetInternalformativ().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetInternalformativ) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetInternalformativ)
}
var _ = atom.Atom(&GlGetString{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetString.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetString().
// Upon returning the glGetString() return value will be stored on the stack.
func (ϟa *GlGetString) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Param {
case GLenum_GL_EXTENSIONS, GLenum_GL_RENDERER, GLenum_GL_SHADING_LANGUAGE_VERSION, GLenum_GL_VENDOR, GLenum_GL_VERSION:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Param); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ret := ϟa.Result
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(ret).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
_ = ret
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetString().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetString() return value will be stored on the stack.
func (ϟa *GlGetString) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Param))
ϟb.Call(funcInfoGlGetString)
}
var _ = atom.Atom(&GlGetStringi{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetStringi.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetStringi().
// Upon returning the glGetStringi() return value will be stored on the stack.
func (ϟa *GlGetStringi) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Name {
case GLenum_GL_EXTENSIONS:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Name); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ret := ϟa.Result
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(ret).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
_ = ret
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetStringi().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glGetStringi() return value will be stored on the stack.
func (ϟa *GlGetStringi) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Name))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetStringi)
}
var _ = atom.Atom(&GlIsEnabled{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsEnabled.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsEnabled().
// Upon returning the glIsEnabled() return value will be stored on the stack.
func (ϟa *GlIsEnabled) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetCapability(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, GLuint(uint32(0)))
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsEnabled().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsEnabled() return value will be stored on the stack.
func (ϟa *GlIsEnabled) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Call(funcInfoGlIsEnabled)
}
var _ = atom.Atom(&GlIsEnabledi{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsEnabledi.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsEnabledi().
// Upon returning the glIsEnabledi() return value will be stored on the stack.
func (ϟa *GlIsEnabledi) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsEnabledi(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Capability, ϟa.Index)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsEnabledi().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsEnabledi() return value will be stored on the stack.
func (ϟa *GlIsEnabledi) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Capability))
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsEnabledi)
}
var _ = atom.Atom(&GlClientWaitSync{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClientWaitSync.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClientWaitSync().
// Upon returning the glClientWaitSync() return value will be stored on the stack.
func (ϟa *GlClientWaitSync) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subClientWaitSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.SyncFlags, ϟa.Timeout); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClientWaitSync().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glClientWaitSync() return value will be stored on the stack.
func (ϟa *GlClientWaitSync) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.SyncFlags))
ϟb.Push(ϟa.Timeout.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClientWaitSync)
}
var _ = atom.Atom(&GlDeleteSync{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteSync.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteSync().
func (ϟa *GlDeleteSync) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDeleteSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteSync().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteSync) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteSync)
}
var _ = atom.Atom(&GlFenceSync{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFenceSync.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFenceSync().
// Upon returning the glFenceSync() return value will be stored on the stack.
func (ϟa *GlFenceSync) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
sync := GLsync(ϟa.Result)
if ϟerr := subFenceSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Condition, ϟa.SyncFlags, sync); ϟerr != nil {
return ϟerr
}
_ = sync
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFenceSync().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glFenceSync() return value will be stored on the stack.
func (ϟa *GlFenceSync) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Condition))
ϟb.Push(value.U32(ϟa.SyncFlags))
ϟb.Call(funcInfoGlFenceSync)
if key, remap := ϟa.Result.remap(ϟa, ϟs); remap {
ptr, found := ϟb.Remappings[key]
if !found {
ptr = ϟb.AllocateMemory(uint64(ϟs.MemoryLayout.PointerSize))
ϟb.Remappings[key] = ptr
}
ϟb.Clone(0)
ϟb.Store(ptr)
}
}
var _ = atom.Atom(&GlGetSynciv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSynciv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSynciv().
func (ϟa *GlGetSynciv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSynciv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.Pname, ϟa.BufSize, ϟa.Length, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSynciv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSynciv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSynciv)
}
var _ = atom.Atom(&GlIsSync{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsSync.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsSync().
// Upon returning the glIsSync() return value will be stored on the stack.
func (ϟa *GlIsSync) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsSync().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsSync() return value will be stored on the stack.
func (ϟa *GlIsSync) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsSync)
}
var _ = atom.Atom(&GlWaitSync{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWaitSync.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWaitSync().
func (ϟa *GlWaitSync) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subWaitSync(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sync, ϟa.SyncFlags, ϟa.Timeout); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWaitSync().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWaitSync) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Sync.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_AbsolutePointer, ϟa.Sync.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Sync.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.SyncFlags))
ϟb.Push(ϟa.Timeout.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWaitSync)
}
var _ = atom.Atom(&GlActiveTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glActiveTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glActiveTexture().
func (ϟa *GlActiveTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Unit {
case GLenum_GL_TEXTURE0, GLenum_GL_TEXTURE1, GLenum_GL_TEXTURE10, GLenum_GL_TEXTURE11, GLenum_GL_TEXTURE12, GLenum_GL_TEXTURE13, GLenum_GL_TEXTURE14, GLenum_GL_TEXTURE15, GLenum_GL_TEXTURE16, GLenum_GL_TEXTURE17, GLenum_GL_TEXTURE18, GLenum_GL_TEXTURE19, GLenum_GL_TEXTURE2, GLenum_GL_TEXTURE20, GLenum_GL_TEXTURE21, GLenum_GL_TEXTURE22, GLenum_GL_TEXTURE23, GLenum_GL_TEXTURE24, GLenum_GL_TEXTURE25, GLenum_GL_TEXTURE26, GLenum_GL_TEXTURE27, GLenum_GL_TEXTURE28, GLenum_GL_TEXTURE29, GLenum_GL_TEXTURE3, GLenum_GL_TEXTURE30, GLenum_GL_TEXTURE31, GLenum_GL_TEXTURE4, GLenum_GL_TEXTURE5, GLenum_GL_TEXTURE6, GLenum_GL_TEXTURE7, GLenum_GL_TEXTURE8, GLenum_GL_TEXTURE9:
default:
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.TextureUnits.Contains(ϟa.Unit)) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Unit); ϟerr != nil {
return ϟerr
}
}
ctx.ActiveTextureUnit = ϟa.Unit
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glActiveTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlActiveTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Unit))
ϟb.Call(funcInfoGlActiveTexture)
}
var _ = atom.Atom(&GlBindImageTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindImageTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindImageTexture().
func (ϟa *GlBindImageTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Access {
case GLenum_GL_READ_ONLY, GLenum_GL_READ_WRITE, GLenum_GL_WRITE_ONLY:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Access); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Format {
case GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Format); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ctx.ImageUnits[ϟa.Unit] = ImageUnit{Name: ϟa.Texture, Level: ϟa.Level, Layered: ϟa.Layered, Layer: ϟa.Layer, Access: ϟa.Access, Format: ϟa.Format}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindImageTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindImageTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Unit.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layered.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Layer.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Access))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Call(funcInfoGlBindImageTexture)
}
var _ = atom.Atom(&GlBindSampler{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindSampler.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindSampler().
func (ϟa *GlBindSampler) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
unit := GLenum((ϟa.Index) + (GLuint(GLenum_GL_TEXTURE0)))
ctx.TextureUnits.Get(unit).SamplerBinding = ϟa.Sampler
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindSampler().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindSampler) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindSampler)
}
var _ = atom.Atom(&GlBindTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindTexture().
func (ϟa *GlBindTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Texture) != (TextureId(uint32(0))) {
if !(ctx.Instances.Textures.Contains(ϟa.Texture)) {
if (ϟa.Target) == (GLenum_GL_TEXTURE_EXTERNAL_OES) {
ctx.Instances.Textures[ϟa.Texture] = (&Texture{ID: ϟa.Texture, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_CLAMP_TO_EDGE, WrapT: GLenum_GL_CLAMP_TO_EDGE, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
} else {
ctx.Instances.Textures[ϟa.Texture] = (&Texture{ID: ϟa.Texture, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
}
}
t := ctx.Instances.Textures.Get(ϟa.Texture)
if (t.OnAccess(ϟs).Kind) == (GLenum(int32(0))) {
t.OnAccess(ϟs).Kind = ϟa.Target
} else {
if (t.OnAccess(ϟs).Kind) != (ϟa.Target) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
}
}
tu := ctx.TextureUnits.Get(ctx.ActiveTextureUnit)
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tu.Binding2d = ϟa.Texture
case GLenum_GL_TEXTURE_EXTERNAL_OES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tu.BindingExternalOes = ϟa.Texture
case GLenum_GL_TEXTURE_2D_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tu.Binding2dArray = ϟa.Texture
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
tu.Binding2dMultisample = ϟa.Texture
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
tu.Binding2dMultisampleArray = ϟa.Texture
case GLenum_GL_TEXTURE_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tu.Binding3d = ϟa.Texture
case GLenum_GL_TEXTURE_BUFFER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
tu.BindingBuffer = ϟa.Texture
case GLenum_GL_TEXTURE_CUBE_MAP:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tu.BindingCubeMap = ϟa.Texture
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
tu.BindingCubeMapArray = ϟa.Texture
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindTexture)
}
var _ = atom.Atom(&GlCompressedTexImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexImage2D().
func (ϟa *GlCompressedTexImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Format {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ATC_RGB_AMD, GLenum_GL_ATC_RGBA_EXPLICIT_ALPHA_AMD, GLenum_GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_AMD_compressed_ATC_texture); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ETC1_RGB8_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_compressed_ETC1_RGB8_texture); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_compression_s3tc); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Format); ϟerr != nil {
return ϟerr
}
}
if ((ϟa.Border) != (GLint(int32(0)))) || ((ϟa.ImageSize) < (GLsizei(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Target, ϟa.Level, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_2D)
if ϟerr != nil {
return ϟerr
}
l := Image{Width: ϟa.Width, Height: ϟa.Height, Size: uint32(ϟa.ImageSize), TexelFormat: ϟa.Format}
if ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᶜᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
t.OnAccess(ϟs).Texture2D[ϟa.Level] = l
t.OnAccess(ϟs).TexelFormat = ϟa.Format
case GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_CUBE_MAP)
if ϟerr != nil {
return ϟerr
}
l := Image{Width: ϟa.Width, Height: ϟa.Height, Size: uint32(ϟa.ImageSize), TexelFormat: ϟa.Format}
if ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᶜᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
cube := t.OnAccess(ϟs).Cubemap.Get(ϟa.Level)
cube.Faces[ϟa.Target] = l
t.OnAccess(ϟs).Cubemap[ϟa.Level] = cube
t.OnAccess(ϟs).TexelFormat = ϟa.Format
default:
v := ϟa.Target
return fmt.Errorf("Missing switch case handler for value %T %v", v, v)
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexImage2D)
}
var _ = atom.Atom(&GlCompressedTexImage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexImage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexImage3D().
func (ϟa *GlCompressedTexImage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCompressedTexImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Border, ϟa.ImageSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexImage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexImage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexImage3D)
}
var _ = atom.Atom(&GlCompressedTexSubImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexSubImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexSubImage2D().
func (ϟa *GlCompressedTexSubImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Format {
case GLenum_GL_COMPRESSED_R11_EAC, GLenum_GL_COMPRESSED_RG11_EAC, GLenum_GL_COMPRESSED_RGB8_ETC2, GLenum_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GLenum_GL_COMPRESSED_RGBA8_ETC2_EAC, GLenum_GL_COMPRESSED_SIGNED_R11_EAC, GLenum_GL_COMPRESSED_SIGNED_RG11_EAC, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GLenum_GL_COMPRESSED_SRGB8_ETC2, GLenum_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGBA_ASTC_10x10, GLenum_GL_COMPRESSED_RGBA_ASTC_10x5, GLenum_GL_COMPRESSED_RGBA_ASTC_10x6, GLenum_GL_COMPRESSED_RGBA_ASTC_10x8, GLenum_GL_COMPRESSED_RGBA_ASTC_12x10, GLenum_GL_COMPRESSED_RGBA_ASTC_12x12, GLenum_GL_COMPRESSED_RGBA_ASTC_4x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x4, GLenum_GL_COMPRESSED_RGBA_ASTC_5x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x5, GLenum_GL_COMPRESSED_RGBA_ASTC_6x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x5, GLenum_GL_COMPRESSED_RGBA_ASTC_8x6, GLenum_GL_COMPRESSED_RGBA_ASTC_8x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, GLenum_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_ETC1_RGB8_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_compressed_ETC1_RGB8_texture); ϟerr != nil {
return ϟerr
}
case GLenum_GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GLenum_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_compression_s3tc); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Format); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ((ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᶜᵖ{}))) {
U8ᵖ(ϟa.Data).Slice(uint64(GLsizei(int32(0))), uint64(ϟa.ImageSize), ϟs).OnRead(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexSubImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexSubImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexSubImage2D)
}
var _ = atom.Atom(&GlCompressedTexSubImage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCompressedTexSubImage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCompressedTexSubImage3D().
func (ϟa *GlCompressedTexSubImage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCompressedTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Format, ϟa.ImageSize, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCompressedTexSubImage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCompressedTexSubImage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(ϟa.ImageSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexSubImage3D)
}
var _ = atom.Atom(&GlCopyImageSubData{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyImageSubData.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyImageSubData().
func (ϟa *GlCopyImageSubData) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyImageSubData(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.SrcName, ϟa.SrcTarget, ϟa.SrcLevel, ϟa.SrcX, ϟa.SrcY, ϟa.SrcZ, ϟa.DstName, ϟa.DstTarget, ϟa.DstLevel, ϟa.DstX, ϟa.DstY, ϟa.DstZ, ϟa.SrcWidth, ϟa.SrcHeight, ϟa.SrcDepth); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyImageSubData().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyImageSubData) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.SrcName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.SrcTarget))
ϟb.Push(ϟa.SrcLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstName.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.DstTarget))
ϟb.Push(ϟa.DstLevel.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstX.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstY.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.DstZ.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcWidth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcHeight.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.SrcDepth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyImageSubData)
}
var _ = atom.Atom(&GlCopyTexImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyTexImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyTexImage2D().
func (ϟa *GlCopyTexImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
case GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
if (ϟa.Width) != (ϟa.Height) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Internalformat {
case GLenum_GL_ALPHA, GLenum_GL_LUMINANCE, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_RGB, GLenum_GL_RGBA:
case GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Internalformat); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Border) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Target, ϟa.Level, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyTexImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyTexImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyTexImage2D)
}
var _ = atom.Atom(&GlCopyTexSubImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyTexSubImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyTexSubImage2D().
func (ϟa *GlCopyTexSubImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Target, ϟa.Level, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ((ϟa.Xoffset) < (GLint(int32(0)))) || ((ϟa.Yoffset) < (GLint(int32(0)))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target)
if ϟerr != nil {
return ϟerr
}
if !(t.OnAccess(ϟs).Texture2D.Contains(ϟa.Level)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
l := t.OnAccess(ϟs).Texture2D.Get(ϟa.Level)
if (((GLsizei(ϟa.Xoffset)) + (ϟa.Width)) > (l.Width)) || (((GLsizei(ϟa.Yoffset)) + (ϟa.Height)) > (l.Height)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyTexSubImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyTexSubImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyTexSubImage2D)
}
var _ = atom.Atom(&GlCopyTexSubImage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCopyTexSubImage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCopyTexSubImage3D().
func (ϟa *GlCopyTexSubImage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subCopyTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.X, ϟa.Y, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCopyTexSubImage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCopyTexSubImage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCopyTexSubImage3D)
}
var _ = atom.Atom(&GlDeleteSamplers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteSamplers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteSamplers().
func (ϟa *GlDeleteSamplers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := ϟa.Samplers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := s.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (SamplerId(uint32(0))) {
delete(ctx.Instances.Samplers, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteSamplers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteSamplers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Samplers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteSamplers)
}
var _ = atom.Atom(&GlDeleteTextures{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteTextures.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteTextures().
func (ϟa *GlDeleteTextures) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t := ϟa.Textures.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := t.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (TextureId(uint32(0))) {
delete(ctx.Instances.Textures, id)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteTextures().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteTextures) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Textures.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteTextures)
}
var _ = atom.Atom(&GlGenSamplers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenSamplers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenSamplers().
func (ϟa *GlGenSamplers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
s := ϟa.Samplers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := SamplerId(ϟa.Samplers.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Samplers[id] = &Sampler{BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, MaxAnisotropy: GLfloat(float32(1))}
s.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenSamplers().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenSamplers) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Samplers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenSamplers)
}
var _ = atom.Atom(&GlGenTextures{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenTextures.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenTextures().
func (ϟa *GlGenTextures) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Count) < (GLsizei(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
t := ϟa.Textures.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
id := TextureId(ϟa.Textures.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.Textures[id] = (&Texture{ID: id, Texture2D: GLintːImageᵐ{}, Cubemap: GLintːCubemapLevelᵐ{}, SwizzleR: GLenum_GL_RED, SwizzleG: GLenum_GL_GREEN, SwizzleB: GLenum_GL_BLUE, SwizzleA: GLenum_GL_ALPHA, BorderColor: Vec4f{Elements: [4]GLfloat{GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(0))}}, MinFilter: GLenum_GL_NEAREST_MIPMAP_LINEAR, MagFilter: GLenum_GL_LINEAR, WrapS: GLenum_GL_REPEAT, WrapT: GLenum_GL_REPEAT, WrapR: GLenum_GL_REPEAT, MinLod: GLfloat(float32(-1000)), MaxLod: GLfloat(float32(1000)), BaseLevel: GLint(int32(0)), MaxLevel: GLint(int32(1000)), DepthStencilTextureMode: GLenum_GL_DEPTH_COMPONENT, CompareMode: GLenum_GL_NONE, CompareFunc: GLenum_GL_LEQUAL, ImmutableFormat: GLboolean_GL_FALSE, ImmutableLevels: GLuint(uint32(0)), MaxAnisotropy: GLfloat(float32(1))}).OnCreate(ϟs)
t.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenTextures().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenTextures) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Textures.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenTextures)
}
var _ = atom.Atom(&GlGenerateMipmap{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenerateMipmap.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenerateMipmap().
func (ϟa *GlGenerateMipmap) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP:
case GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_3D:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenerateMipmap().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenerateMipmap) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlGenerateMipmap)
}
var _ = atom.Atom(&GlGetSamplerParameterIiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIiv().
func (ϟa *GlGetSamplerParameterIiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIiv)
}
var _ = atom.Atom(&GlGetSamplerParameterIuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterIuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterIuiv().
func (ϟa *GlGetSamplerParameterIuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterIuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterIuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterIuiv)
}
var _ = atom.Atom(&GlGetSamplerParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameterfv().
func (ϟa *GlGetSamplerParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterv_GLfloat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameterfv)
}
var _ = atom.Atom(&GlGetSamplerParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetSamplerParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetSamplerParameteriv().
func (ϟa *GlGetSamplerParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetSamplerParameterv_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetSamplerParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetSamplerParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetSamplerParameteriv)
}
var _ = atom.Atom(&GlGetTexLevelParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexLevelParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexLevelParameterfv().
func (ϟa *GlGetTexLevelParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_2D_MULTISAMPLE, GLenum_GL_TEXTURE_3D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_BUFFER, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Pname {
case GLenum_GL_TEXTURE_ALPHA_SIZE, GLenum_GL_TEXTURE_ALPHA_TYPE, GLenum_GL_TEXTURE_BLUE_SIZE, GLenum_GL_TEXTURE_BLUE_TYPE, GLenum_GL_TEXTURE_COMPRESSED, GLenum_GL_TEXTURE_DEPTH, GLenum_GL_TEXTURE_DEPTH_SIZE, GLenum_GL_TEXTURE_DEPTH_TYPE, GLenum_GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, GLenum_GL_TEXTURE_GREEN_SIZE, GLenum_GL_TEXTURE_GREEN_TYPE, GLenum_GL_TEXTURE_HEIGHT, GLenum_GL_TEXTURE_INTERNAL_FORMAT, GLenum_GL_TEXTURE_RED_SIZE, GLenum_GL_TEXTURE_RED_TYPE, GLenum_GL_TEXTURE_SAMPLES, GLenum_GL_TEXTURE_SHARED_SIZE, GLenum_GL_TEXTURE_STENCIL_SIZE, GLenum_GL_TEXTURE_WIDTH:
case GLenum_GL_TEXTURE_BUFFER_DATA_STORE_BINDING, GLenum_GL_TEXTURE_BUFFER_OFFSET, GLenum_GL_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexLevelParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexLevelParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexLevelParameterfv)
}
var _ = atom.Atom(&GlGetTexLevelParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexLevelParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexLevelParameteriv().
func (ϟa *GlGetTexLevelParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_2D_ARRAY, GLenum_GL_TEXTURE_2D_MULTISAMPLE, GLenum_GL_TEXTURE_3D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GLenum_GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GLenum_GL_TEXTURE_BUFFER, GLenum_GL_TEXTURE_CUBE_MAP_ARRAY:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Pname {
case GLenum_GL_TEXTURE_ALPHA_SIZE, GLenum_GL_TEXTURE_ALPHA_TYPE, GLenum_GL_TEXTURE_BLUE_SIZE, GLenum_GL_TEXTURE_BLUE_TYPE, GLenum_GL_TEXTURE_COMPRESSED, GLenum_GL_TEXTURE_DEPTH, GLenum_GL_TEXTURE_DEPTH_SIZE, GLenum_GL_TEXTURE_DEPTH_TYPE, GLenum_GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, GLenum_GL_TEXTURE_GREEN_SIZE, GLenum_GL_TEXTURE_GREEN_TYPE, GLenum_GL_TEXTURE_HEIGHT, GLenum_GL_TEXTURE_INTERNAL_FORMAT, GLenum_GL_TEXTURE_RED_SIZE, GLenum_GL_TEXTURE_RED_TYPE, GLenum_GL_TEXTURE_SAMPLES, GLenum_GL_TEXTURE_SHARED_SIZE, GLenum_GL_TEXTURE_STENCIL_SIZE, GLenum_GL_TEXTURE_WIDTH:
case GLenum_GL_TEXTURE_BUFFER_DATA_STORE_BINDING, GLenum_GL_TEXTURE_BUFFER_OFFSET, GLenum_GL_TEXTURE_BUFFER_SIZE:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexLevelParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexLevelParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexLevelParameteriv)
}
var _ = atom.Atom(&GlGetTexParameterIiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIiv().
func (ϟa *GlGetTexParameterIiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIiv)
}
var _ = atom.Atom(&GlGetTexParameterIuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterIuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterIuiv().
func (ϟa *GlGetTexParameterIuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterIuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterIuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterIuiv)
}
var _ = atom.Atom(&GlGetTexParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterfv().
func (ϟa *GlGetTexParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameter_GLfloat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterfv)
}
var _ = atom.Atom(&GlGetTexParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameteriv().
func (ϟa *GlGetTexParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGetTexParameter_GLint(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, ϟa.Values); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameteriv)
}
var _ = atom.Atom(&GlIsSampler{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsSampler.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsSampler().
// Upon returning the glIsSampler() return value will be stored on the stack.
func (ϟa *GlIsSampler) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Samplers.Contains(ϟa.Sampler) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsSampler().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsSampler() return value will be stored on the stack.
func (ϟa *GlIsSampler) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsSampler)
}
var _ = atom.Atom(&GlIsTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsTexture().
// Upon returning the glIsTexture() return value will be stored on the stack.
func (ϟa *GlIsTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.Textures.Contains(ϟa.Texture) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsTexture() return value will be stored on the stack.
func (ϟa *GlIsTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsTexture)
}
var _ = atom.Atom(&GlPixelStorei{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPixelStorei.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPixelStorei().
func (ϟa *GlPixelStorei) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Value) < (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
switch ϟa.Parameter {
case GLenum_GL_PACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ((ϟa.Value) != (GLint(int32(1)))) && (((ϟa.Value) != (GLint(int32(2)))) && (((ϟa.Value) != (GLint(int32(4)))) && ((ϟa.Value) != (GLint(int32(8)))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.PixelStorage.PackAlignment = ϟa.Value
case GLenum_GL_PACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.PackImageHeight = ϟa.Value
case GLenum_GL_PACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.PackRowLength = ϟa.Value
case GLenum_GL_PACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.PackSkipImages = ϟa.Value
case GLenum_GL_PACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.PackSkipPixels = ϟa.Value
case GLenum_GL_PACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.PackSkipRows = ϟa.Value
case GLenum_GL_UNPACK_ALIGNMENT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ((ϟa.Value) != (GLint(int32(1)))) && (((ϟa.Value) != (GLint(int32(2)))) && (((ϟa.Value) != (GLint(int32(4)))) && ((ϟa.Value) != (GLint(int32(8)))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx.PixelStorage.UnpackAlignment = ϟa.Value
case GLenum_GL_UNPACK_IMAGE_HEIGHT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.UnpackImageHeight = ϟa.Value
case GLenum_GL_UNPACK_ROW_LENGTH:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.UnpackRowLength = ϟa.Value
case GLenum_GL_UNPACK_SKIP_IMAGES:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.UnpackSkipImages = ϟa.Value
case GLenum_GL_UNPACK_SKIP_PIXELS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.UnpackSkipPixels = ϟa.Value
case GLenum_GL_UNPACK_SKIP_ROWS:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx.PixelStorage.UnpackSkipRows = ϟa.Value
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPixelStorei().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPixelStorei) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPixelStorei)
}
var _ = atom.Atom(&GlSamplerParameterIiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIiv().
func (ϟa *GlSamplerParameterIiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIiv)
}
var _ = atom.Atom(&GlSamplerParameterIuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterIuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterIuiv().
func (ϟa *GlSamplerParameterIuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterIuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterIuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterIuiv)
}
var _ = atom.Atom(&GlSamplerParameterf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterf().
func (ϟa *GlSamplerParameterf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params := Vec1f{Elements: [1]GLfloat{ϟa.Param}}
if ϟerr := subSamplerParameterv_Vec1f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterf)
}
var _ = atom.Atom(&GlSamplerParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameterfv().
func (ϟa *GlSamplerParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterv_GLfloat__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameterfv)
}
var _ = atom.Atom(&GlSamplerParameteri{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameteri.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameteri().
func (ϟa *GlSamplerParameteri) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
params := Vec1i{Elements: [1]GLint{ϟa.Param}}
if ϟerr := subSamplerParameterv_Vec1i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameteri().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameteri) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameteri)
}
var _ = atom.Atom(&GlSamplerParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSamplerParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSamplerParameteriv().
func (ϟa *GlSamplerParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subSamplerParameterv_GLint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Sampler, ϟa.Pname, ϟa.Param); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSamplerParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSamplerParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Sampler.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSamplerParameteriv)
}
var _ = atom.Atom(&GlTexBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBuffer().
func (ϟa *GlTexBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlTexBuffer)
}
var _ = atom.Atom(&GlTexBufferRange{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexBufferRange.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexBufferRange().
func (ϟa *GlTexBufferRange) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexBufferRange(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Internalformat, ϟa.Buffer, ϟa.Offset, ϟa.Size); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexBufferRange().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexBufferRange) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexBufferRange)
}
var _ = atom.Atom(&GlTexImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexImage2D().
func (ϟa *GlTexImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
case GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
if (ϟa.Width) != (ϟa.Height) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subCheckInternalFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum(ϟa.Internalformat)); ϟerr != nil {
return ϟerr
}
switch ϟa.Format {
case GLenum_GL_ALPHA, GLenum_GL_LUMINANCE, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_RGB, GLenum_GL_RGBA:
case GLenum_GL_DEPTH_COMPONENT, GLenum_GL_DEPTH_STENCIL, GLenum_GL_RED, GLenum_GL_RED_INTEGER, GLenum_GL_RG, GLenum_GL_RGBA_INTEGER, GLenum_GL_RGB_INTEGER, GLenum_GL_RG_INTEGER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_STENCIL_INDEX:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BGRA_EXT:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_EXT_texture_format_BGRA8888); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Format); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Type {
case GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_SHORT_4_4_4_4, GLenum_GL_UNSIGNED_SHORT_5_5_5_1, GLenum_GL_UNSIGNED_SHORT_5_6_5:
case GLenum_GL_HALF_FLOAT_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_half_float); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BYTE, GLenum_GL_FLOAT, GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GLenum_GL_HALF_FLOAT, GLenum_GL_INT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV, GLenum_GL_UNSIGNED_INT_24_8, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_5_9_9_9_REV, GLenum_GL_UNSIGNED_SHORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
if (ϟa.Border) != (GLint(int32(0))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Target, ϟa.Level, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_2D)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
l := Image{Width: ϟa.Width, Height: ϟa.Height, Size: _res_0, TexelFormat: ϟa.Format, TexelType: ϟa.Type}
if (ϟa.Data) != (TexturePointer(Voidᶜᵖ{})) {
if (ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
} else {
l.Data = MakeU8ˢ(uint64(l.Size), ϟs)
}
t.OnAccess(ϟs).Texture2D[ϟa.Level] = l
t.OnAccess(ϟs).TexelFormat = ϟa.Format
t.OnAccess(ϟs).TexelType = ϟa.Type
case GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLenum_GL_TEXTURE_CUBE_MAP)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
l := Image{Width: ϟa.Width, Height: ϟa.Height, Size: _res_0, TexelFormat: ϟa.Format, TexelType: ϟa.Type}
if (ϟa.Data) != (TexturePointer(Voidᶜᵖ{})) {
if (ctx.BoundBuffers.PixelUnpackBuffer) == (BufferId(uint32(0))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟctx, ϟa, ϟs, ϟd, ϟb)
}
} else {
l.Data = MakeU8ˢ(uint64(l.Size), ϟs)
}
cube := t.OnAccess(ϟs).Cubemap.Get(ϟa.Level)
cube.Faces[ϟa.Target] = l
t.OnAccess(ϟs).Cubemap[ϟa.Level] = cube
t.OnAccess(ϟs).TexelFormat = ϟa.Format
t.OnAccess(ϟs).TexelType = ϟa.Type
default:
v := ϟa.Target
return fmt.Errorf("Missing switch case handler for value %T %v", v, v)
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Internalformat.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexImage2D)
}
var _ = atom.Atom(&GlTexImage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexImage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexImage3D().
func (ϟa *GlTexImage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Border, ϟa.Format, ϟa.Type, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexImage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexImage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Internalformat.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Border.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexImage3D)
}
var _ = atom.Atom(&GlTexParameterIiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIiv().
func (ϟa *GlTexParameterIiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIiv)
}
var _ = atom.Atom(&GlTexParameterIuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterIuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterIuiv().
func (ϟa *GlTexParameterIuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterIuiv(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterIuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterIuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterIuiv)
}
var _ = atom.Atom(&GlTexParameterf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterf().
func (ϟa *GlTexParameterf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Parameter) == (GLenum_GL_TEXTURE_BORDER_COLOR) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
params := Vec1f{Elements: [1]GLfloat{ϟa.Value}}
if ϟerr := subTexParameterv_Vec1f(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterf)
}
var _ = atom.Atom(&GlTexParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterfv().
func (ϟa *GlTexParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterv_GLfloat__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterfv)
}
var _ = atom.Atom(&GlTexParameteri{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameteri.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameteri().
func (ϟa *GlTexParameteri) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if (ϟa.Parameter) == (GLenum_GL_TEXTURE_BORDER_COLOR) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Parameter); ϟerr != nil {
return ϟerr
}
}
params := Vec1i{Elements: [1]GLint{ϟa.Value}}
if ϟerr := subTexParameterv_Vec1i(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Parameter, params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameteri().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameteri) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameteri)
}
var _ = atom.Atom(&GlTexParameteriv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameteriv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameteriv().
func (ϟa *GlTexParameteriv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexParameterv_GLint__CP(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Pname, ϟa.Params); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameteriv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameteriv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameteriv)
}
var _ = atom.Atom(&GlTexStorage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage2D().
func (ϟa *GlTexStorage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage2D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Levels, ϟa.Internalformat, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage2D)
}
var _ = atom.Atom(&GlTexStorage2DMultisample{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage2DMultisample.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage2DMultisample().
func (ϟa *GlTexStorage2DMultisample) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D_MULTISAMPLE:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Internalformat {
case GLenum_GL_DEPTH24_STENCIL8, GLenum_GL_DEPTH32F_STENCIL8, GLenum_GL_DEPTH_COMPONENT16, GLenum_GL_DEPTH_COMPONENT24, GLenum_GL_DEPTH_COMPONENT32F, GLenum_GL_R11F_G11F_B10F, GLenum_GL_R16F, GLenum_GL_R16I, GLenum_GL_R16UI, GLenum_GL_R32F, GLenum_GL_R32I, GLenum_GL_R32UI, GLenum_GL_R8, GLenum_GL_R8I, GLenum_GL_R8UI, GLenum_GL_R8_SNORM, GLenum_GL_RG16F, GLenum_GL_RG16I, GLenum_GL_RG16UI, GLenum_GL_RG32F, GLenum_GL_RG32I, GLenum_GL_RG32UI, GLenum_GL_RG8, GLenum_GL_RG8I, GLenum_GL_RG8UI, GLenum_GL_RG8_SNORM, GLenum_GL_RGB10_A2, GLenum_GL_RGB10_A2UI, GLenum_GL_RGB16F, GLenum_GL_RGB16I, GLenum_GL_RGB16UI, GLenum_GL_RGB32F, GLenum_GL_RGB32I, GLenum_GL_RGB32UI, GLenum_GL_RGB565, GLenum_GL_RGB5_A1, GLenum_GL_RGB8, GLenum_GL_RGB8I, GLenum_GL_RGB8UI, GLenum_GL_RGB8_SNORM, GLenum_GL_RGB9_E5, GLenum_GL_RGBA16F, GLenum_GL_RGBA16I, GLenum_GL_RGBA16UI, GLenum_GL_RGBA32F, GLenum_GL_RGBA32I, GLenum_GL_RGBA32UI, GLenum_GL_RGBA4, GLenum_GL_RGBA8, GLenum_GL_RGBA8I, GLenum_GL_RGBA8UI, GLenum_GL_RGBA8_SNORM, GLenum_GL_SRGB8, GLenum_GL_SRGB8_ALPHA8:
case GLenum_GL_STENCIL_INDEX8:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Internalformat); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage2DMultisample().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage2DMultisample) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fixedsamplelocations.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage2DMultisample)
}
var _ = atom.Atom(&GlTexStorage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage3D().
func (ϟa *GlTexStorage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Levels, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage3D)
}
var _ = atom.Atom(&GlTexStorage3DMultisample{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage3DMultisample.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage3DMultisample().
func (ϟa *GlTexStorage3DMultisample) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(2))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexStorage3DMultisample(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Samples, ϟa.Internalformat, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Fixedsamplelocations); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage3DMultisample().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage3DMultisample) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Samples.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Fixedsamplelocations.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage3DMultisample)
}
var _ = atom.Atom(&GlTexSubImage2D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexSubImage2D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexSubImage2D().
func (ϟa *GlTexSubImage2D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
if ((ϟa.Level) < (GLint(int32(0)))) || (((ϟa.Xoffset) < (GLint(int32(0)))) || (((ϟa.Yoffset) < (GLint(int32(0)))) || (((ϟa.Width) < (GLsizei(int32(0)))) || ((ϟa.Height) < (GLsizei(int32(0))))))) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subCheckMaxTextureSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Target, ϟa.Level, ϟa.Width, ϟa.Height); ϟerr != nil {
return ϟerr
}
switch ϟa.Format {
case GLenum_GL_ALPHA, GLenum_GL_LUMINANCE, GLenum_GL_LUMINANCE_ALPHA, GLenum_GL_RGB, GLenum_GL_RGBA:
case GLenum_GL_DEPTH_COMPONENT, GLenum_GL_DEPTH_STENCIL, GLenum_GL_RED, GLenum_GL_RED_INTEGER, GLenum_GL_RG, GLenum_GL_RGBA_INTEGER, GLenum_GL_RGB_INTEGER, GLenum_GL_RG_INTEGER:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Format); ϟerr != nil {
return ϟerr
}
}
switch ϟa.Type {
case GLenum_GL_UNSIGNED_BYTE, GLenum_GL_UNSIGNED_SHORT_4_4_4_4, GLenum_GL_UNSIGNED_SHORT_5_5_5_1, GLenum_GL_UNSIGNED_SHORT_5_6_5:
case GLenum_GL_HALF_FLOAT_OES:
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_half_float); ϟerr != nil {
return ϟerr
}
case GLenum_GL_BYTE, GLenum_GL_FLOAT, GLenum_GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GLenum_GL_HALF_FLOAT, GLenum_GL_INT, GLenum_GL_SHORT, GLenum_GL_UNSIGNED_INT, GLenum_GL_UNSIGNED_INT_10F_11F_11F_REV, GLenum_GL_UNSIGNED_INT_24_8, GLenum_GL_UNSIGNED_INT_2_10_10_10_REV, GLenum_GL_UNSIGNED_INT_5_9_9_9_REV, GLenum_GL_UNSIGNED_SHORT:
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Type); ϟerr != nil {
return ϟerr
}
}
t, ϟerr := subGetBoundTextureOrErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, func() (result GLenum) {
switch ϟa.Target {
case GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
return GLenum_GL_TEXTURE_CUBE_MAP
default:
return ϟa.Target
}
}())
if ϟerr != nil {
return ϟerr
}
image := func() (result Image) {
switch ϟa.Target {
case GLenum_GL_TEXTURE_2D:
return t.OnAccess(ϟs).Texture2D.Get(ϟa.Level)
case GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GLenum_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
return t.OnAccess(ϟs).Cubemap.Get(ϟa.Level).Faces.Get(ϟa.Target)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Target, ϟa))
return result
}
}()
if (((GLsizei(ϟa.Xoffset)) + (ϟa.Width)) > (image.Width)) || (((GLsizei(ϟa.Yoffset)) + (ϟa.Height)) > (image.Height)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
pbo := ctx.BoundBuffers.PixelUnpackBuffer
url := ctx.PixelStorage.UnpackRowLength
src_width := func() (result uint32) {
switch (url) == (GLint(int32(0))) {
case true:
return uint32(ϟa.Width)
case false:
return uint32(url)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (url) == (GLint(int32(0))), ϟa))
return result
}
}()
src_stride, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, src_width, uint32(1), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
src_size := (src_stride) * (uint32(ϟa.Height))
dst_stride, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(image.Width), uint32(1), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(ϟa.Xoffset), uint32(1), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
dst_offset := (_res_0) + ((dst_stride) * (uint32(ϟa.Yoffset)))
src_data := func() (result U8ˢ) {
switch (pbo) == (BufferId(uint32(0))) {
case true:
return U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(src_size), ϟs)
case false:
return ctx.Instances.Buffers.Get(pbo).Data.Slice(uint64(ϟa.Data.Address), (uint64(ϟa.Data.Address))+(uint64(src_size)), ϟs)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (pbo) == (BufferId(uint32(0))), ϟa))
return result
}
}()
line_bytes, ϟerr := subImageSize(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, uint32(ϟa.Width), uint32(1), ϟa.Format, ϟa.Type)
if ϟerr != nil {
return ϟerr
}
for y := uint32(0); y < uint32(ϟa.Height); y++ {
src := (src_stride) * (y)
dst := ((dst_stride) * (y)) + (dst_offset)
image.Data.Slice(uint64(dst), uint64((dst)+(line_bytes)), ϟs).Copy(ϟctx, src_data.Slice(uint64(src), uint64((src)+(line_bytes)), ϟs), ϟa, ϟs, ϟd, ϟb)
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexSubImage2D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexSubImage2D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexSubImage2D)
}
var _ = atom.Atom(&GlTexSubImage3D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexSubImage3D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexSubImage3D().
func (ϟa *GlTexSubImage3D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subTexSubImage3D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Level, ϟa.Xoffset, ϟa.Yoffset, ϟa.Zoffset, ϟa.Width, ϟa.Height, ϟa.Depth, ϟa.Format, ϟa.Type, ϟa.Data); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexSubImage3D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexSubImage3D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Xoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Yoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Zoffset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexSubImage3D)
}
var _ = atom.Atom(&GlBeginTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBeginTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBeginTransformFeedback().
func (ϟa *GlBeginTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.PrimitiveMode {
case GLenum_GL_LINES, GLenum_GL_POINTS, GLenum_GL_TRIANGLES:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.PrimitiveMode); ϟerr != nil {
return ϟerr
}
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_0.Active = GLboolean(uint8(1))
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBeginTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBeginTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.PrimitiveMode))
ϟb.Call(funcInfoGlBeginTransformFeedback)
}
var _ = atom.Atom(&GlBindTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindTransformFeedback().
func (ϟa *GlBindTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.Target {
case GLenum_GL_TRANSFORM_FEEDBACK:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target); ϟerr != nil {
return ϟerr
}
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if !(ctx.Instances.TransformFeedbacks.Contains(ϟa.Id)) {
ctx.Instances.TransformFeedbacks[ϟa.Id] = &TransformFeedback{Buffers: GLuintːBufferBindingᵐ{}, Paused: GLboolean_GL_FALSE, Active: GLboolean_GL_FALSE}
}
ctx.BoundTransformFeedback = ϟa.Id
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindTransformFeedback)
}
var _ = atom.Atom(&GlDeleteTransformFeedbacks{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteTransformFeedbacks.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteTransformFeedbacks().
func (ϟa *GlDeleteTransformFeedbacks) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tfs := ϟa.Ids.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.N), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
for i := GLsizei(int32(0)); i < ϟa.N; i++ {
id := tfs.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)
if (id) != (TransformFeedbackId(uint32(0))) {
ctx.Instances.TransformFeedbacks[id] = (*TransformFeedback)(nil)
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteTransformFeedbacks().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteTransformFeedbacks) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteTransformFeedbacks)
}
var _ = atom.Atom(&GlEndTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEndTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEndTransformFeedback().
func (ϟa *GlEndTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_0.Paused = GLboolean(uint8(0))
_res_1, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_1.Active = GLboolean(uint8(0))
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEndTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEndTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlEndTransformFeedback)
}
var _ = atom.Atom(&GlGenTransformFeedbacks{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenTransformFeedbacks.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenTransformFeedbacks().
func (ϟa *GlGenTransformFeedbacks) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
tfs := ϟa.Ids.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.N), ϟs)
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
for i := GLsizei(int32(0)); i < ϟa.N; i++ {
id := TransformFeedbackId(ϟa.Ids.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.N), ϟs).Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil))
ctx.Instances.TransformFeedbacks[id] = &TransformFeedback{Buffers: GLuintːBufferBindingᵐ{}, Paused: GLboolean_GL_FALSE, Active: GLboolean_GL_FALSE}
tfs.Index(uint64(i), ϟs).Write(ϟctx, id, ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenTransformFeedbacks().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenTransformFeedbacks) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ids.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenTransformFeedbacks)
}
var _ = atom.Atom(&GlGetTransformFeedbackVarying{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTransformFeedbackVarying.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTransformFeedbackVarying().
func (ϟa *GlGetTransformFeedbackVarying) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subWriteString(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufSize, ϟa.Length, ϟa.Name); ϟerr != nil {
return ϟerr
}
ϟa.Size.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Size.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Type.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTransformFeedbackVarying().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTransformFeedbackVarying) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BufSize.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Length.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Type.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Name.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTransformFeedbackVarying)
}
var _ = atom.Atom(&GlIsTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsTransformFeedback().
// Upon returning the glIsTransformFeedback() return value will be stored on the stack.
func (ϟa *GlIsTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = func() GLboolean {
if ctx.Instances.TransformFeedbacks.Contains(ϟa.Id) {
return 1
} else {
return 0
}
}()
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsTransformFeedback() return value will be stored on the stack.
func (ϟa *GlIsTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Id.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsTransformFeedback)
}
var _ = atom.Atom(&GlPauseTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPauseTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPauseTransformFeedback().
func (ϟa *GlPauseTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_0.Paused = GLboolean(uint8(1))
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPauseTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPauseTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPauseTransformFeedback)
}
var _ = atom.Atom(&GlResumeTransformFeedback{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glResumeTransformFeedback.
// If ϟb is not nil, Mutate also emits the replay instructions to call glResumeTransformFeedback().
func (ϟa *GlResumeTransformFeedback) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subGetBoundTransformFeedback(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
_res_0.Paused = GLboolean(uint8(0))
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glResumeTransformFeedback().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlResumeTransformFeedback) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlResumeTransformFeedback)
}
var _ = atom.Atom(&GlTransformFeedbackVaryings{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTransformFeedbackVaryings.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTransformFeedbackVaryings().
func (ϟa *GlTransformFeedbackVaryings) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
switch ϟa.BufferMode {
case GLenum_GL_INTERLEAVED_ATTRIBS, GLenum_GL_SEPARATE_ATTRIBS:
default:
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.BufferMode); ϟerr != nil {
return ϟerr
}
}
names := ϟa.Varyings.Slice(uint64(GLsizei(int32(0))), uint64(ϟa.Count), ϟs)
for i := GLsizei(int32(0)); i < ϟa.Count; i++ {
_ = strings.TrimRight(string(gfxapi.CharToBytes(Charᵖ(names.Index(uint64(i), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)).StringSlice(ϟctx, ϟs, ϟd).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))), "\x00")
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTransformFeedbackVaryings().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTransformFeedbackVaryings) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Varyings.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.BufferMode))
ϟb.Call(funcInfoGlTransformFeedbackVaryings)
}
var _ = atom.Atom(&GlBindVertexArray{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindVertexArray.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindVertexArray().
func (ϟa *GlBindVertexArray) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subBindVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Array); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindVertexArray().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindVertexArray) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindVertexArray)
}
var _ = atom.Atom(&GlBindVertexBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindVertexBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindVertexBuffer().
func (ϟa *GlBindVertexBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subBindVertexBuffer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.BindingIndex, ϟa.Buffer, ϟa.Offset, ϟa.Stride); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindVertexBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindVertexBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.BindingIndex.value(ϟb, ϟa, ϟs))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Offset.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindVertexBuffer)
}
var _ = atom.Atom(&GlDeleteVertexArrays{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteVertexArrays.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteVertexArrays().
func (ϟa *GlDeleteVertexArrays) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subDeleteVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.Arrays); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteVertexArrays().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteVertexArrays) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Arrays.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteVertexArrays)
}
var _ = atom.Atom(&GlDisableVertexAttribArray{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableVertexAttribArray.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableVertexAttribArray().
func (ϟa *GlDisableVertexAttribArray) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Location) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexAttributeArrays.Get(ϟa.Location).Enabled = GLboolean_GL_FALSE
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableVertexAttribArray().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableVertexAttribArray) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableVertexAttribArray)
}
var _ = atom.Atom(&GlEnableVertexAttribArray{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableVertexAttribArray.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableVertexAttribArray().
func (ϟa *GlEnableVertexAttribArray) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Location) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexAttributeArrays.Get(ϟa.Location).Enabled = GLboolean_GL_TRUE
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableVertexAttribArray().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableVertexAttribArray) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableVertexAttribArray)
}
var _ = atom.Atom(&GlGenVertexArrays{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenVertexArrays.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenVertexArrays().
func (ϟa *GlGenVertexArrays) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subGenVertexArrays(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Count, ϟa.Arrays); ϟerr != nil {
return ϟerr
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenVertexArrays().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenVertexArrays) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Arrays.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenVertexArrays)
}
var _ = atom.Atom(&GlGetVertexAttribIiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetVertexAttribIiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetVertexAttribIiv().
func (ϟa *GlGetVertexAttribIiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Index) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Pname) == (GLenum_GL_CURRENT_VERTEX_ATTRIB) {
ϟa.Params.Slice(uint64(0), uint64(4), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_res_0, ϟerr := subGetVertexAttrib(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Pname)
if ϟerr != nil {
return ϟerr
}
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0), ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetVertexAttribIiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetVertexAttribIiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetVertexAttribIiv)
}
var _ = atom.Atom(&GlGetVertexAttribIuiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetVertexAttribIuiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetVertexAttribIuiv().
func (ϟa *GlGetVertexAttribIuiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Index) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Pname) == (GLenum_GL_CURRENT_VERTEX_ATTRIB) {
ϟa.Params.Slice(uint64(0), uint64(4), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_res_0, ϟerr := subGetVertexAttrib(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Pname)
if ϟerr != nil {
return ϟerr
}
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLuint(_res_0), ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetVertexAttribIuiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetVertexAttribIuiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetVertexAttribIuiv)
}
var _ = atom.Atom(&GlGetVertexAttribPointerv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetVertexAttribPointerv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetVertexAttribPointerv().
func (ϟa *GlGetVertexAttribPointerv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Index) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (ϟa.Pname) != (GLenum_GL_VERTEX_ATTRIB_ARRAY_POINTER) {
if ϟerr := subGlErrorInvalidEnum(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Pname); ϟerr != nil {
return ϟerr
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Pointer.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, Voidᵖ(vao.VertexAttributeArrays.Get(ϟa.Index).Pointer), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetVertexAttribPointerv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetVertexAttribPointerv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetVertexAttribPointerv)
}
var _ = atom.Atom(&GlGetVertexAttribfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetVertexAttribfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetVertexAttribfv().
func (ϟa *GlGetVertexAttribfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Index) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Pname) == (GLenum_GL_CURRENT_VERTEX_ATTRIB) {
ϟa.Params.Slice(uint64(0), uint64(4), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_res_0, ϟerr := subGetVertexAttrib(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Pname)
if ϟerr != nil {
return ϟerr
}
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLfloat(_res_0), ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetVertexAttribfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetVertexAttribfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetVertexAttribfv)
}
var _ = atom.Atom(&GlGetVertexAttribiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetVertexAttribiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetVertexAttribiv().
func (ϟa *GlGetVertexAttribiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.Index) >= (AttributeLocation(ctx.Constants.MaxVertexAttribs)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if (ϟa.Pname) == (GLenum_GL_CURRENT_VERTEX_ATTRIB) {
ϟa.Params.Slice(uint64(0), uint64(4), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
} else {
_res_0, ϟerr := subGetVertexAttrib(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Pname)
if ϟerr != nil {
return ϟerr
}
ϟa.Params.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, GLint(_res_0), ϟa, ϟs, ϟd, ϟb)
}
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetVertexAttribiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetVertexAttribiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetVertexAttribiv)
}
var _ = atom.Atom(&GlIsVertexArray{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsVertexArray.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsVertexArray().
// Upon returning the glIsVertexArray() return value will be stored on the stack.
func (ϟa *GlIsVertexArray) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
_res_0, ϟerr := subIsVertexArray(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Array)
if ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = _res_0
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsVertexArray().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsVertexArray() return value will be stored on the stack.
func (ϟa *GlIsVertexArray) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsVertexArray)
}
var _ = atom.Atom(&GlVertexAttrib1f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib1f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib1f().
func (ϟa *GlVertexAttrib1f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, Vec4f{Elements: [4]GLfloat{ϟa.Value0, GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(1))}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib1f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib1f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib1f)
}
var _ = atom.Atom(&GlVertexAttrib1fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib1fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib1fv().
func (ϟa *GlVertexAttrib1fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Value.Slice(uint64(0), uint64(1), ϟs)
vec := Vec4f{Elements: [4]GLfloat{v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), GLfloat(float32(0)), GLfloat(float32(0)), GLfloat(float32(1))}}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib1fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib1fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib1fv)
}
var _ = atom.Atom(&GlVertexAttrib2f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib2f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib2f().
func (ϟa *GlVertexAttrib2f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, Vec4f{Elements: [4]GLfloat{ϟa.Value0, ϟa.Value1, GLfloat(float32(0)), GLfloat(float32(1))}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib2f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib2f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib2f)
}
var _ = atom.Atom(&GlVertexAttrib2fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib2fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib2fv().
func (ϟa *GlVertexAttrib2fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Value.Slice(uint64(0), uint64(2), ϟs)
vec := Vec4f{Elements: [4]GLfloat{v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), GLfloat(float32(0)), GLfloat(float32(1))}}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib2fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib2fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib2fv)
}
var _ = atom.Atom(&GlVertexAttrib3f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib3f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib3f().
func (ϟa *GlVertexAttrib3f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, Vec4f{Elements: [4]GLfloat{ϟa.Value0, ϟa.Value1, ϟa.Value2, GLfloat(float32(1))}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib3f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib3f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib3f)
}
var _ = atom.Atom(&GlVertexAttrib3fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib3fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib3fv().
func (ϟa *GlVertexAttrib3fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Value.Slice(uint64(0), uint64(3), ϟs)
vec := Vec4f{Elements: [4]GLfloat{v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), GLfloat(float32(1))}}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib3fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib3fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib3fv)
}
var _ = atom.Atom(&GlVertexAttrib4f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib4f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib4f().
func (ϟa *GlVertexAttrib4f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, Vec4f{Elements: [4]GLfloat{ϟa.Value0, ϟa.Value1, ϟa.Value2, ϟa.Value3}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib4f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib4f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib4f)
}
var _ = atom.Atom(&GlVertexAttrib4fv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttrib4fv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttrib4fv().
func (ϟa *GlVertexAttrib4fv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Value.Slice(uint64(0), uint64(4), ϟs)
vec := Vec4f{Elements: [4]GLfloat{v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(3), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)}}
if ϟerr := subVertexAttribF(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Location, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttrib4fv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttrib4fv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttrib4fv)
}
var _ = atom.Atom(&GlVertexAttribBinding{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribBinding.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribBinding().
func (ϟa *GlVertexAttribBinding) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subVertexAttribBinding(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.BindingIndex); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribBinding().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribBinding) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BindingIndex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribBinding)
}
var _ = atom.Atom(&GlVertexAttribDivisor{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribDivisor.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribDivisor().
func (ϟa *GlVertexAttribDivisor) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribDivisor(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, ϟa.Divisor); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribDivisor().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribDivisor) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Divisor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribDivisor)
}
var _ = atom.Atom(&GlVertexAttribFormat{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribFormat.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribFormat().
func (ϟa *GlVertexAttribFormat) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subVertexAttribFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Size, ϟa.Type, ϟa.Normalized, ϟa.Relativeoffset, false); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribFormat().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribFormat) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Normalized.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Relativeoffset.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribFormat)
}
var _ = atom.Atom(&GlVertexAttribI4i{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribI4i.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribI4i().
func (ϟa *GlVertexAttribI4i) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribI(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, Vec4i{Elements: [4]GLint{ϟa.X, ϟa.Y, ϟa.Z, ϟa.W}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribI4i().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribI4i) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribI4i)
}
var _ = atom.Atom(&GlVertexAttribI4iv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribI4iv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribI4iv().
func (ϟa *GlVertexAttribI4iv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Values.Slice(uint64(0), uint64(4), ϟs)
vec := Vec4i{Elements: [4]GLint{v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb), v.Index(uint64(3), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)}}
if ϟerr := subVertexAttribI(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribI4iv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribI4iv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribI4iv)
}
var _ = atom.Atom(&GlVertexAttribI4ui{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribI4ui.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribI4ui().
func (ϟa *GlVertexAttribI4ui) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribI(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, Vec4i{Elements: [4]GLint{GLint(ϟa.X), GLint(ϟa.Y), GLint(ϟa.Z), GLint(ϟa.W)}}); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribI4ui().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribI4ui) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.W.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribI4ui)
}
var _ = atom.Atom(&GlVertexAttribI4uiv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribI4uiv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribI4uiv().
func (ϟa *GlVertexAttribI4uiv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
v := ϟa.Values.Slice(uint64(0), uint64(4), ϟs)
vec := Vec4i{Elements: [4]GLint{GLint(v.Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)), GLint(v.Index(uint64(1), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)), GLint(v.Index(uint64(2), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb)), GLint(v.Index(uint64(3), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, ϟb))}}
if ϟerr := subVertexAttribI(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Index, vec); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribI4uiv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribI4uiv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Values.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribI4uiv)
}
var _ = atom.Atom(&GlVertexAttribIFormat{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribIFormat.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribIFormat().
func (ϟa *GlVertexAttribIFormat) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if ϟerr := subVertexAttribFormat(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Index, ϟa.Size, ϟa.Type, GLboolean(uint8(0)), ϟa.Relativeoffset, true); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribIFormat().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribIFormat) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Index.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Relativeoffset.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribIFormat)
}
var _ = atom.Atom(&GlVertexAttribIPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribIPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribIPointer().
func (ϟa *GlVertexAttribIPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribPointer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Location, ϟa.Size, ϟa.Type, GLboolean(uint8(0)), ϟa.Stride, ϟa.Data, true); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribIPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribIPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribIPointer)
}
var _ = atom.Atom(&GlVertexAttribPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexAttribPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexAttribPointer().
func (ϟa *GlVertexAttribPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(2)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if ϟerr := subVertexAttribPointer(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ctx, ϟa.Location, ϟa.Size, ϟa.Type, ϟa.Normalized, ϟa.Stride, ϟa.Data, false); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexAttribPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexAttribPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Normalized.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribPointer)
}
var _ = atom.Atom(&GlVertexBindingDivisor{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexBindingDivisor.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexBindingDivisor().
func (ϟa *GlVertexBindingDivisor) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(3)), GLint(int32(1))); ϟerr != nil {
return ϟerr
}
ctx, ϟerr := subGetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
if (ϟa.BindingIndex) >= (VertexBufferBindingIndex(ctx.Constants.MaxVertexAttribBindings)) {
if ϟerr := subGlErrorInvalidValue(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
if (ctx.BoundVertexArray) == (VertexArrayId(uint32(0))) {
if ϟerr := subGlErrorInvalidOperation(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
}
vao := ctx.Instances.VertexArrays.Get(ctx.BoundVertexArray)
vao.VertexBufferBindings.Get(ϟa.BindingIndex).Divisor = ϟa.Divisor
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexBindingDivisor().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexBindingDivisor) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.BindingIndex.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Divisor.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexBindingDivisor)
}
var _ = atom.Atom(&GlXCreateContext{}) // interface compliance check
func (ϟa *GlXCreateContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Result
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.GLXContexts[context] = _res_0
_ = context
return nil
}
var _ = atom.Atom(&GlXCreateNewContext{}) // interface compliance check
func (ϟa *GlXCreateNewContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Result
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.GLXContexts[context] = _res_0
_ = context
return nil
}
var _ = atom.Atom(&GlXMakeContextCurrent{}) // interface compliance check
func (ϟa *GlXMakeContextCurrent) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟc.GLXContexts.Get(ϟa.Ctx)); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&GlXMakeCurrent{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glXMakeCurrent.
// If ϟb is not nil, Mutate also emits the replay instructions to call glXMakeCurrent().
// Upon returning the glXMakeCurrent() return value will be stored on the stack.
func (ϟa *GlXMakeCurrent) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟc.GLXContexts.Get(ϟa.Ctx)); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&GlXSwapBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glXSwapBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call glXSwapBuffers().
func (ϟa *GlXSwapBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
var _ = atom.Atom(&GlXQueryDrawable{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glXQueryDrawable.
// If ϟb is not nil, Mutate also emits the replay instructions to call glXQueryDrawable().
// Upon returning the glXQueryDrawable() return value will be stored on the stack.
func (ϟa *GlXQueryDrawable) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&WglCreateContext{}) // interface compliance check
func (ϟa *WglCreateContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Result
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.WGLContexts[context] = _res_0
_ = context
return nil
}
var _ = atom.Atom(&WglCreateContextAttribsARB{}) // interface compliance check
func (ϟa *WglCreateContextAttribsARB) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Result
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.WGLContexts[context] = _res_0
_ = context
return nil
}
var _ = atom.Atom(&WglMakeCurrent{}) // interface compliance check
func (ϟa *WglMakeCurrent) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟc.WGLContexts.Get(ϟa.Hglrc)); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&WglSwapBuffers{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for wglSwapBuffers.
// If ϟb is not nil, Mutate also emits the replay instructions to call wglSwapBuffers().
func (ϟa *WglSwapBuffers) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
var _ = atom.Atom(&CGLCreateContext{}) // interface compliance check
func (ϟa *CGLCreateContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
context := ϟa.Ctx.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil)
_res_0, ϟerr := subCreateContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb)
if ϟerr != nil {
return ϟerr
}
ϟc.CGLContexts[context] = _res_0
ϟa.Ctx.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, context, ϟa, ϟs, ϟd, ϟb)
_ = context
return nil
}
var _ = atom.Atom(&CGLSetCurrentContext{}) // interface compliance check
func (ϟa *CGLSetCurrentContext) mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subSetContext(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟc.CGLContexts.Get(ϟa.Ctx)); ϟerr != nil {
return ϟerr
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&CGLGetSurface{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for CGLGetSurface.
// If ϟb is not nil, Mutate also emits the replay instructions to call CGLGetSurface().
// Upon returning the CGLGetSurface() return value will be stored on the stack.
func (ϟa *CGLGetSurface) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Cid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Cid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
ϟa.Wid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Wid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
ϟa.Sid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Sid.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&CGSGetSurfaceBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for CGSGetSurfaceBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call CGSGetSurfaceBounds().
// Upon returning the CGSGetSurfaceBounds() return value will be stored on the stack.
func (ϟa *CGSGetSurfaceBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Bounds.Slice(uint64(0), uint64(4), ϟs).OnWrite(ϟctx, ϟa, ϟs, ϟd, ϟb)
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&CGLFlushDrawable{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for CGLFlushDrawable.
// If ϟb is not nil, Mutate also emits the replay instructions to call CGLFlushDrawable().
// Upon returning the CGLFlushDrawable() return value will be stored on the stack.
func (ϟa *CGLFlushDrawable) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟb = nil // @no_replay
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
var _ = atom.Atom(&GlGetQueryObjecti64v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjecti64v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjecti64v().
func (ϟa *GlGetQueryObjecti64v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjecti64v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjecti64v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjecti64v)
}
var _ = atom.Atom(&GlGetQueryObjectui64v{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetQueryObjectui64v.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetQueryObjectui64v().
func (ϟa *GlGetQueryObjectui64v) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Write(ϟctx, ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).Read(ϟctx, ϟa, ϟs, ϟd, nil), ϟa, ϟs, ϟd, ϟb)
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetQueryObjectui64v().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetQueryObjectui64v) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Query.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Query.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Query.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetQueryObjectui64v)
}
var _ = atom.Atom(&GlTexStorage1D{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexStorage1D.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexStorage1D().
func (ϟa *GlTexStorage1D) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexStorage1D().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexStorage1D) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Levels.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexStorage1D)
}
var _ = atom.Atom(&GlBindFragDataLocation{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindFragDataLocation.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindFragDataLocation().
func (ϟa *GlBindFragDataLocation) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindFragDataLocation().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindFragDataLocation) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Color.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlBindFragDataLocation)
}
var _ = atom.Atom(&GlAlphaFunc{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glAlphaFunc.
// If ϟb is not nil, Mutate also emits the replay instructions to call glAlphaFunc().
func (ϟa *GlAlphaFunc) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glAlphaFunc().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlAlphaFunc) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlAlphaFunc)
}
var _ = atom.Atom(&GlAlphaFuncx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glAlphaFuncx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glAlphaFuncx().
func (ϟa *GlAlphaFuncx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glAlphaFuncx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlAlphaFuncx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlAlphaFuncx)
}
var _ = atom.Atom(&GlAlphaFuncxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glAlphaFuncxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glAlphaFuncxOES().
func (ϟa *GlAlphaFuncxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glAlphaFuncxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlAlphaFuncxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Func))
ϟb.Push(ϟa.Ref.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlAlphaFuncxOES)
}
var _ = atom.Atom(&GlBindFramebufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindFramebufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindFramebufferOES().
func (ϟa *GlBindFramebufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindFramebufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindFramebufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindFramebufferOES)
}
var _ = atom.Atom(&GlBindRenderbufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBindRenderbufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBindRenderbufferOES().
func (ϟa *GlBindRenderbufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBindRenderbufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBindRenderbufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlBindRenderbufferOES)
}
var _ = atom.Atom(&GlBlendEquationOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationOES().
func (ϟa *GlBlendEquationOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_blend_subtract); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlBlendEquationOES)
}
var _ = atom.Atom(&GlBlendEquationSeparateOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendEquationSeparateOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendEquationSeparateOES().
func (ϟa *GlBlendEquationSeparateOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_blend_equation_separate); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendEquationSeparateOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendEquationSeparateOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.ModeRGB))
ϟb.Push(value.U32(ϟa.ModeAlpha))
ϟb.Call(funcInfoGlBlendEquationSeparateOES)
}
var _ = atom.Atom(&GlBlendFuncSeparateOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glBlendFuncSeparateOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glBlendFuncSeparateOES().
func (ϟa *GlBlendFuncSeparateOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_blend_func_separate); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glBlendFuncSeparateOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlBlendFuncSeparateOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.SrcRGB))
ϟb.Push(value.U32(ϟa.DstRGB))
ϟb.Push(value.U32(ϟa.SrcAlpha))
ϟb.Push(value.U32(ϟa.DstAlpha))
ϟb.Call(funcInfoGlBlendFuncSeparateOES)
}
var _ = atom.Atom(&GlCheckFramebufferStatusOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCheckFramebufferStatusOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCheckFramebufferStatusOES().
// Upon returning the glCheckFramebufferStatusOES() return value will be stored on the stack.
func (ϟa *GlCheckFramebufferStatusOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCheckFramebufferStatusOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glCheckFramebufferStatusOES() return value will be stored on the stack.
func (ϟa *GlCheckFramebufferStatusOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlCheckFramebufferStatusOES)
}
var _ = atom.Atom(&GlClearColorx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearColorx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearColorx().
func (ϟa *GlClearColorx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearColorx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearColorx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearColorx)
}
var _ = atom.Atom(&GlClearColorxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearColorxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearColorxOES().
func (ϟa *GlClearColorxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearColorxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearColorxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearColorxOES)
}
var _ = atom.Atom(&GlClearDepthfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearDepthfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearDepthfOES().
func (ϟa *GlClearDepthfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearDepthfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearDepthfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearDepthfOES)
}
var _ = atom.Atom(&GlClearDepthx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearDepthx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearDepthx().
func (ϟa *GlClearDepthx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearDepthx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearDepthx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearDepthx)
}
var _ = atom.Atom(&GlClearDepthxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClearDepthxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClearDepthxOES().
func (ϟa *GlClearDepthxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClearDepthxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClearDepthxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Depth.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClearDepthxOES)
}
var _ = atom.Atom(&GlClientActiveTexture{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClientActiveTexture.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClientActiveTexture().
func (ϟa *GlClientActiveTexture) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClientActiveTexture().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClientActiveTexture) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Texture))
ϟb.Call(funcInfoGlClientActiveTexture)
}
var _ = atom.Atom(&GlClipPlanef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanef().
func (ϟa *GlClipPlanef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.P))
ϟb.Push(ϟa.Eqn.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanef)
}
var _ = atom.Atom(&GlClipPlanefIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanefIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanefIMG().
func (ϟa *GlClipPlanefIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_user_clip_plane); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanefIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanefIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.P))
ϟb.Push(ϟa.Eqn.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanefIMG)
}
var _ = atom.Atom(&GlClipPlanefOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanefOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanefOES().
func (ϟa *GlClipPlanefOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanefOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanefOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanefOES)
}
var _ = atom.Atom(&GlClipPlanex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanex().
func (ϟa *GlClipPlanex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanex)
}
var _ = atom.Atom(&GlClipPlanexIMG{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanexIMG.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanexIMG().
func (ϟa *GlClipPlanexIMG) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_IMG_user_clip_plane); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanexIMG().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanexIMG) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.P))
ϟb.Push(ϟa.Eqn.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanexIMG)
}
var _ = atom.Atom(&GlClipPlanexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glClipPlanexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glClipPlanexOES().
func (ϟa *GlClipPlanexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glClipPlanexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlClipPlanexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlClipPlanexOES)
}
var _ = atom.Atom(&GlColor4f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColor4f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColor4f().
func (ϟa *GlColor4f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColor4f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColor4f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColor4f)
}
var _ = atom.Atom(&GlColor4ub{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColor4ub.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColor4ub().
func (ϟa *GlColor4ub) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColor4ub().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColor4ub) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColor4ub)
}
var _ = atom.Atom(&GlColor4x{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColor4x.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColor4x().
func (ϟa *GlColor4x) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColor4x().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColor4x) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColor4x)
}
var _ = atom.Atom(&GlColor4xOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColor4xOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColor4xOES().
func (ϟa *GlColor4xOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColor4xOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColor4xOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColor4xOES)
}
var _ = atom.Atom(&GlColorPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorPointer().
func (ϟa *GlColorPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorPointer)
}
var _ = atom.Atom(&GlCurrentPaletteMatrixOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glCurrentPaletteMatrixOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glCurrentPaletteMatrixOES().
func (ϟa *GlCurrentPaletteMatrixOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glCurrentPaletteMatrixOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlCurrentPaletteMatrixOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Matrixpaletteindex.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCurrentPaletteMatrixOES)
}
var _ = atom.Atom(&GlDeleteFramebuffersOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteFramebuffersOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteFramebuffersOES().
func (ϟa *GlDeleteFramebuffersOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteFramebuffersOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteFramebuffersOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Framebuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteFramebuffersOES)
}
var _ = atom.Atom(&GlDeleteRenderbuffersOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDeleteRenderbuffersOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDeleteRenderbuffersOES().
func (ϟa *GlDeleteRenderbuffersOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDeleteRenderbuffersOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDeleteRenderbuffersOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Renderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDeleteRenderbuffersOES)
}
var _ = atom.Atom(&GlDepthRangefOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangefOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangefOES().
func (ϟa *GlDepthRangefOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangefOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangefOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangefOES)
}
var _ = atom.Atom(&GlDepthRangex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangex().
func (ϟa *GlDepthRangex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangex)
}
var _ = atom.Atom(&GlDepthRangexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDepthRangexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDepthRangexOES().
func (ϟa *GlDepthRangexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDepthRangexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDepthRangexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDepthRangexOES)
}
var _ = atom.Atom(&GlDisableClientState{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDisableClientState.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDisableClientState().
func (ϟa *GlDisableClientState) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDisableClientState().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDisableClientState) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Array))
ϟb.Call(funcInfoGlDisableClientState)
}
var _ = atom.Atom(&GlDrawTexfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexfOES().
func (ϟa *GlDrawTexfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexfOES)
}
var _ = atom.Atom(&GlDrawTexfvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexfvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexfvOES().
func (ϟa *GlDrawTexfvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexfvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexfvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexfvOES)
}
var _ = atom.Atom(&GlDrawTexiOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexiOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexiOES().
func (ϟa *GlDrawTexiOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexiOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexiOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexiOES)
}
var _ = atom.Atom(&GlDrawTexivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexivOES().
func (ϟa *GlDrawTexivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexivOES)
}
var _ = atom.Atom(&GlDrawTexsOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexsOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexsOES().
func (ϟa *GlDrawTexsOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexsOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexsOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexsOES)
}
var _ = atom.Atom(&GlDrawTexsvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexsvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexsvOES().
func (ϟa *GlDrawTexsvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexsvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexsvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexsvOES)
}
var _ = atom.Atom(&GlDrawTexxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexxOES().
func (ϟa *GlDrawTexxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexxOES)
}
var _ = atom.Atom(&GlDrawTexxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glDrawTexxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glDrawTexxvOES().
func (ϟa *GlDrawTexxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_draw_texture); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glDrawTexxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlDrawTexxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Coords.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDrawTexxvOES)
}
var _ = atom.Atom(&GlEnableClientState{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glEnableClientState.
// If ϟb is not nil, Mutate also emits the replay instructions to call glEnableClientState().
func (ϟa *GlEnableClientState) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glEnableClientState().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlEnableClientState) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Array))
ϟb.Call(funcInfoGlEnableClientState)
}
var _ = atom.Atom(&GlFogf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogf().
func (ϟa *GlFogf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogf)
}
var _ = atom.Atom(&GlFogfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogfv().
func (ϟa *GlFogfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogfv)
}
var _ = atom.Atom(&GlFogx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogx().
func (ϟa *GlFogx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogx)
}
var _ = atom.Atom(&GlFogxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogxOES().
func (ϟa *GlFogxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogxOES)
}
var _ = atom.Atom(&GlFogxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogxv().
func (ϟa *GlFogxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogxv)
}
var _ = atom.Atom(&GlFogxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFogxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFogxvOES().
func (ϟa *GlFogxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFogxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFogxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFogxvOES)
}
var _ = atom.Atom(&GlFramebufferRenderbufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferRenderbufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferRenderbufferOES().
func (ϟa *GlFramebufferRenderbufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferRenderbufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferRenderbufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Renderbuffertarget))
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferRenderbufferOES)
}
var _ = atom.Atom(&GlFramebufferTexture2DOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFramebufferTexture2DOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFramebufferTexture2DOES().
func (ϟa *GlFramebufferTexture2DOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subFramebufferTexture2D(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ϟa.Target, ϟa.Attachment, ϟa.Textarget, ϟa.Texture, ϟa.Level); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFramebufferTexture2DOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFramebufferTexture2DOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Textarget))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, protocol.Type_Uint32, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Level.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFramebufferTexture2DOES)
}
var _ = atom.Atom(&GlFrustumf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFrustumf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFrustumf().
func (ϟa *GlFrustumf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFrustumf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFrustumf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFrustumf)
}
var _ = atom.Atom(&GlFrustumfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFrustumfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFrustumfOES().
func (ϟa *GlFrustumfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFrustumfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFrustumfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFrustumfOES)
}
var _ = atom.Atom(&GlFrustumx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFrustumx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFrustumx().
func (ϟa *GlFrustumx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFrustumx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFrustumx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFrustumx)
}
var _ = atom.Atom(&GlFrustumxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glFrustumxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glFrustumxOES().
func (ϟa *GlFrustumxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glFrustumxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlFrustumxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlFrustumxOES)
}
var _ = atom.Atom(&GlGenFramebuffersOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenFramebuffersOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenFramebuffersOES().
func (ϟa *GlGenFramebuffersOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenFramebuffersOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenFramebuffersOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Framebuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenFramebuffersOES)
}
var _ = atom.Atom(&GlGenRenderbuffersOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenRenderbuffersOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenRenderbuffersOES().
func (ϟa *GlGenRenderbuffersOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenRenderbuffersOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenRenderbuffersOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Renderbuffers.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGenRenderbuffersOES)
}
var _ = atom.Atom(&GlGenerateMipmapOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGenerateMipmapOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGenerateMipmapOES().
func (ϟa *GlGenerateMipmapOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGenerateMipmapOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGenerateMipmapOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlGenerateMipmapOES)
}
var _ = atom.Atom(&GlGetClipPlanef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetClipPlanef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetClipPlanef().
func (ϟa *GlGetClipPlanef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetClipPlanef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetClipPlanef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetClipPlanef)
}
var _ = atom.Atom(&GlGetClipPlanefOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetClipPlanefOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetClipPlanefOES().
func (ϟa *GlGetClipPlanefOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetClipPlanefOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetClipPlanefOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetClipPlanefOES)
}
var _ = atom.Atom(&GlGetClipPlanex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetClipPlanex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetClipPlanex().
func (ϟa *GlGetClipPlanex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetClipPlanex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetClipPlanex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetClipPlanex)
}
var _ = atom.Atom(&GlGetClipPlanexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetClipPlanexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetClipPlanexOES().
func (ϟa *GlGetClipPlanexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetClipPlanexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetClipPlanexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Plane))
ϟb.Push(ϟa.Equation.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetClipPlanexOES)
}
var _ = atom.Atom(&GlGetFixedv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFixedv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFixedv().
func (ϟa *GlGetFixedv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFixedv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFixedv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFixedv)
}
var _ = atom.Atom(&GlGetFixedvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFixedvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFixedvOES().
func (ϟa *GlGetFixedvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFixedvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFixedvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFixedvOES)
}
var _ = atom.Atom(&GlGetFramebufferAttachmentParameterivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetFramebufferAttachmentParameterivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetFramebufferAttachmentParameterivOES().
func (ϟa *GlGetFramebufferAttachmentParameterivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetFramebufferAttachmentParameterivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetFramebufferAttachmentParameterivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Attachment))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetFramebufferAttachmentParameterivOES)
}
var _ = atom.Atom(&GlGetLightfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetLightfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetLightfv().
func (ϟa *GlGetLightfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetLightfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetLightfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetLightfv)
}
var _ = atom.Atom(&GlGetLightxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetLightxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetLightxv().
func (ϟa *GlGetLightxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetLightxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetLightxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetLightxv)
}
var _ = atom.Atom(&GlGetLightxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetLightxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetLightxvOES().
func (ϟa *GlGetLightxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetLightxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetLightxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetLightxvOES)
}
var _ = atom.Atom(&GlGetMaterialfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetMaterialfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetMaterialfv().
func (ϟa *GlGetMaterialfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetMaterialfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetMaterialfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetMaterialfv)
}
var _ = atom.Atom(&GlGetMaterialxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetMaterialxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetMaterialxv().
func (ϟa *GlGetMaterialxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetMaterialxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetMaterialxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetMaterialxv)
}
var _ = atom.Atom(&GlGetMaterialxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetMaterialxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetMaterialxvOES().
func (ϟa *GlGetMaterialxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetMaterialxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetMaterialxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetMaterialxvOES)
}
var _ = atom.Atom(&GlGetRenderbufferParameterivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetRenderbufferParameterivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetRenderbufferParameterivOES().
func (ϟa *GlGetRenderbufferParameterivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetRenderbufferParameterivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetRenderbufferParameterivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetRenderbufferParameterivOES)
}
var _ = atom.Atom(&GlGetTexEnvfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexEnvfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexEnvfv().
func (ϟa *GlGetTexEnvfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexEnvfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexEnvfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexEnvfv)
}
var _ = atom.Atom(&GlGetTexEnviv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexEnviv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexEnviv().
func (ϟa *GlGetTexEnviv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexEnviv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexEnviv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexEnviv)
}
var _ = atom.Atom(&GlGetTexEnvxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexEnvxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexEnvxv().
func (ϟa *GlGetTexEnvxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexEnvxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexEnvxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexEnvxv)
}
var _ = atom.Atom(&GlGetTexEnvxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexEnvxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexEnvxvOES().
func (ϟa *GlGetTexEnvxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexEnvxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexEnvxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexEnvxvOES)
}
var _ = atom.Atom(&GlGetTexGenfvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexGenfvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexGenfvOES().
func (ϟa *GlGetTexGenfvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexGenfvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexGenfvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexGenfvOES)
}
var _ = atom.Atom(&GlGetTexGenivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexGenivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexGenivOES().
func (ϟa *GlGetTexGenivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexGenivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexGenivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexGenivOES)
}
var _ = atom.Atom(&GlGetTexGenxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexGenxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexGenxvOES().
func (ϟa *GlGetTexGenxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexGenxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexGenxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexGenxvOES)
}
var _ = atom.Atom(&GlGetTexParameterxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterxv().
func (ϟa *GlGetTexParameterxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterxv)
}
var _ = atom.Atom(&GlGetTexParameterxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glGetTexParameterxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glGetTexParameterxvOES().
func (ϟa *GlGetTexParameterxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glGetTexParameterxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlGetTexParameterxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlGetTexParameterxvOES)
}
var _ = atom.Atom(&GlIsFramebufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsFramebufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsFramebufferOES().
// Upon returning the glIsFramebufferOES() return value will be stored on the stack.
func (ϟa *GlIsFramebufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsFramebufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsFramebufferOES() return value will be stored on the stack.
func (ϟa *GlIsFramebufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsFramebufferOES)
}
var _ = atom.Atom(&GlIsRenderbufferOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glIsRenderbufferOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glIsRenderbufferOES().
// Upon returning the glIsRenderbufferOES() return value will be stored on the stack.
func (ϟa *GlIsRenderbufferOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glIsRenderbufferOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glIsRenderbufferOES() return value will be stored on the stack.
func (ϟa *GlIsRenderbufferOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlIsRenderbufferOES)
}
var _ = atom.Atom(&GlLightModelf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelf().
func (ϟa *GlLightModelf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelf)
}
var _ = atom.Atom(&GlLightModelfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelfv().
func (ϟa *GlLightModelfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelfv)
}
var _ = atom.Atom(&GlLightModelx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelx().
func (ϟa *GlLightModelx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelx)
}
var _ = atom.Atom(&GlLightModelxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelxOES().
func (ϟa *GlLightModelxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelxOES)
}
var _ = atom.Atom(&GlLightModelxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelxv().
func (ϟa *GlLightModelxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelxv)
}
var _ = atom.Atom(&GlLightModelxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightModelxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightModelxvOES().
func (ϟa *GlLightModelxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightModelxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightModelxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightModelxvOES)
}
var _ = atom.Atom(&GlLightf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightf().
func (ϟa *GlLightf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightf)
}
var _ = atom.Atom(&GlLightfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightfv().
func (ϟa *GlLightfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightfv)
}
var _ = atom.Atom(&GlLightx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightx().
func (ϟa *GlLightx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightx)
}
var _ = atom.Atom(&GlLightxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightxOES().
func (ϟa *GlLightxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightxOES)
}
var _ = atom.Atom(&GlLightxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightxv().
func (ϟa *GlLightxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightxv)
}
var _ = atom.Atom(&GlLightxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLightxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLightxvOES().
func (ϟa *GlLightxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLightxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLightxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Light))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLightxvOES)
}
var _ = atom.Atom(&GlLineWidthx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLineWidthx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLineWidthx().
func (ϟa *GlLineWidthx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLineWidthx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLineWidthx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLineWidthx)
}
var _ = atom.Atom(&GlLineWidthxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLineWidthxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLineWidthxOES().
func (ϟa *GlLineWidthxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLineWidthxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLineWidthxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLineWidthxOES)
}
var _ = atom.Atom(&GlLoadIdentity{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLoadIdentity.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLoadIdentity().
func (ϟa *GlLoadIdentity) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLoadIdentity().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLoadIdentity) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlLoadIdentity)
}
var _ = atom.Atom(&GlLoadMatrixf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLoadMatrixf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLoadMatrixf().
func (ϟa *GlLoadMatrixf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLoadMatrixf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLoadMatrixf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLoadMatrixf)
}
var _ = atom.Atom(&GlLoadMatrixx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLoadMatrixx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLoadMatrixx().
func (ϟa *GlLoadMatrixx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLoadMatrixx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLoadMatrixx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLoadMatrixx)
}
var _ = atom.Atom(&GlLoadMatrixxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLoadMatrixxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLoadMatrixxOES().
func (ϟa *GlLoadMatrixxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLoadMatrixxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLoadMatrixxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlLoadMatrixxOES)
}
var _ = atom.Atom(&GlLoadPaletteFromModelViewMatrixOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLoadPaletteFromModelViewMatrixOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLoadPaletteFromModelViewMatrixOES().
func (ϟa *GlLoadPaletteFromModelViewMatrixOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLoadPaletteFromModelViewMatrixOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLoadPaletteFromModelViewMatrixOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlLoadPaletteFromModelViewMatrixOES)
}
var _ = atom.Atom(&GlLogicOp{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glLogicOp.
// If ϟb is not nil, Mutate also emits the replay instructions to call glLogicOp().
func (ϟa *GlLogicOp) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glLogicOp().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlLogicOp) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Opcode))
ϟb.Call(funcInfoGlLogicOp)
}
var _ = atom.Atom(&GlMaterialf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialf().
func (ϟa *GlMaterialf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialf)
}
var _ = atom.Atom(&GlMaterialfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialfv().
func (ϟa *GlMaterialfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialfv)
}
var _ = atom.Atom(&GlMaterialx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialx().
func (ϟa *GlMaterialx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialx)
}
var _ = atom.Atom(&GlMaterialxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialxOES().
func (ϟa *GlMaterialxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialxOES)
}
var _ = atom.Atom(&GlMaterialxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialxv().
func (ϟa *GlMaterialxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialxv)
}
var _ = atom.Atom(&GlMaterialxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMaterialxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMaterialxvOES().
func (ϟa *GlMaterialxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMaterialxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMaterialxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMaterialxvOES)
}
var _ = atom.Atom(&GlMatrixIndexPointerOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixIndexPointerOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixIndexPointerOES().
func (ϟa *GlMatrixIndexPointerOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixIndexPointerOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixIndexPointerOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixIndexPointerOES)
}
var _ = atom.Atom(&GlMatrixMode{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixMode.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixMode().
func (ϟa *GlMatrixMode) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixMode().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixMode) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlMatrixMode)
}
var _ = atom.Atom(&GlMultMatrixf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultMatrixf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultMatrixf().
func (ϟa *GlMultMatrixf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultMatrixf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultMatrixf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultMatrixf)
}
var _ = atom.Atom(&GlMultMatrixx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultMatrixx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultMatrixx().
func (ϟa *GlMultMatrixx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultMatrixx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultMatrixx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultMatrixx)
}
var _ = atom.Atom(&GlMultMatrixxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultMatrixxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultMatrixxOES().
func (ϟa *GlMultMatrixxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultMatrixxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultMatrixxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.M.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultMatrixxOES)
}
var _ = atom.Atom(&GlMultiTexCoord4f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiTexCoord4f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiTexCoord4f().
func (ϟa *GlMultiTexCoord4f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiTexCoord4f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiTexCoord4f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiTexCoord4f)
}
var _ = atom.Atom(&GlMultiTexCoord4x{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiTexCoord4x.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiTexCoord4x().
func (ϟa *GlMultiTexCoord4x) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiTexCoord4x().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiTexCoord4x) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Texture))
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiTexCoord4x)
}
var _ = atom.Atom(&GlMultiTexCoord4xOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMultiTexCoord4xOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMultiTexCoord4xOES().
func (ϟa *GlMultiTexCoord4xOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMultiTexCoord4xOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMultiTexCoord4xOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Texture))
ϟb.Push(ϟa.V0.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V1.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V2.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.V3.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMultiTexCoord4xOES)
}
var _ = atom.Atom(&GlNormal3f{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNormal3f.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNormal3f().
func (ϟa *GlNormal3f) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNormal3f().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNormal3f) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Nx.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ny.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Nz.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNormal3f)
}
var _ = atom.Atom(&GlNormal3x{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNormal3x.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNormal3x().
func (ϟa *GlNormal3x) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNormal3x().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNormal3x) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Nx.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ny.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Nz.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNormal3x)
}
var _ = atom.Atom(&GlNormal3xOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNormal3xOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNormal3xOES().
func (ϟa *GlNormal3xOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNormal3xOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNormal3xOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Nx.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Ny.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Nz.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNormal3xOES)
}
var _ = atom.Atom(&GlNormalPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNormalPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNormalPointer().
func (ϟa *GlNormalPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNormalPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNormalPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNormalPointer)
}
var _ = atom.Atom(&GlOrthof{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glOrthof.
// If ϟb is not nil, Mutate also emits the replay instructions to call glOrthof().
func (ϟa *GlOrthof) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glOrthof().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlOrthof) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlOrthof)
}
var _ = atom.Atom(&GlOrthofOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glOrthofOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glOrthofOES().
func (ϟa *GlOrthofOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_single_precision); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glOrthofOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlOrthofOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlOrthofOES)
}
var _ = atom.Atom(&GlOrthox{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glOrthox.
// If ϟb is not nil, Mutate also emits the replay instructions to call glOrthox().
func (ϟa *GlOrthox) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glOrthox().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlOrthox) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlOrthox)
}
var _ = atom.Atom(&GlOrthoxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glOrthoxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glOrthoxOES().
func (ϟa *GlOrthoxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glOrthoxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlOrthoxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.L.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.R.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.B.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.T.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.N.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.F.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlOrthoxOES)
}
var _ = atom.Atom(&GlPointParameterf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterf().
func (ϟa *GlPointParameterf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterf)
}
var _ = atom.Atom(&GlPointParameterfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterfv().
func (ϟa *GlPointParameterfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterfv)
}
var _ = atom.Atom(&GlPointParameterx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterx().
func (ϟa *GlPointParameterx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterx)
}
var _ = atom.Atom(&GlPointParameterxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterxOES().
func (ϟa *GlPointParameterxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterxOES)
}
var _ = atom.Atom(&GlPointParameterxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterxv().
func (ϟa *GlPointParameterxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterxv)
}
var _ = atom.Atom(&GlPointParameterxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointParameterxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointParameterxvOES().
func (ϟa *GlPointParameterxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointParameterxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointParameterxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointParameterxvOES)
}
var _ = atom.Atom(&GlPointSize{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointSize.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointSize().
func (ϟa *GlPointSize) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointSize().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointSize) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointSize)
}
var _ = atom.Atom(&GlPointSizePointerOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointSizePointerOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointSizePointerOES().
func (ϟa *GlPointSizePointerOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_point_size_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointSizePointerOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointSizePointerOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointSizePointerOES)
}
var _ = atom.Atom(&GlPointSizex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointSizex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointSizex().
func (ϟa *GlPointSizex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointSizex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointSizex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointSizex)
}
var _ = atom.Atom(&GlPointSizexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointSizexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointSizexOES().
func (ϟa *GlPointSizexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointSizexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointSizexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointSizexOES)
}
var _ = atom.Atom(&GlPolygonOffsetx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPolygonOffsetx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPolygonOffsetx().
func (ϟa *GlPolygonOffsetx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPolygonOffsetx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPolygonOffsetx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Factor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Units.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPolygonOffsetx)
}
var _ = atom.Atom(&GlPolygonOffsetxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPolygonOffsetxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPolygonOffsetxOES().
func (ϟa *GlPolygonOffsetxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPolygonOffsetxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPolygonOffsetxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Factor.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Units.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPolygonOffsetxOES)
}
var _ = atom.Atom(&GlPopMatrix{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPopMatrix.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPopMatrix().
func (ϟa *GlPopMatrix) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPopMatrix().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPopMatrix) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPopMatrix)
}
var _ = atom.Atom(&GlPushMatrix{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPushMatrix.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPushMatrix().
func (ϟa *GlPushMatrix) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPushMatrix().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPushMatrix) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoGlPushMatrix)
}
var _ = atom.Atom(&GlQueryMatrixxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glQueryMatrixxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glQueryMatrixxOES().
// Upon returning the glQueryMatrixxOES() return value will be stored on the stack.
func (ϟa *GlQueryMatrixxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_query_matrix); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glQueryMatrixxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The glQueryMatrixxOES() return value will be stored on the stack.
func (ϟa *GlQueryMatrixxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Mantissa.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Exponent.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlQueryMatrixxOES)
}
var _ = atom.Atom(&GlRenderbufferStorageOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRenderbufferStorageOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRenderbufferStorageOES().
func (ϟa *GlRenderbufferStorageOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_framebuffer_object); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRenderbufferStorageOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRenderbufferStorageOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Internalformat))
ϟb.Push(ϟa.Width.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Height.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRenderbufferStorageOES)
}
var _ = atom.Atom(&GlRotatef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRotatef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRotatef().
func (ϟa *GlRotatef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRotatef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRotatef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Angle.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRotatef)
}
var _ = atom.Atom(&GlRotatex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRotatex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRotatex().
func (ϟa *GlRotatex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRotatex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRotatex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Angle.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRotatex)
}
var _ = atom.Atom(&GlRotatexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glRotatexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glRotatexOES().
func (ϟa *GlRotatexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glRotatexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlRotatexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Angle.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlRotatexOES)
}
var _ = atom.Atom(&GlSampleCoveragex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSampleCoveragex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSampleCoveragex().
func (ϟa *GlSampleCoveragex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSampleCoveragex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSampleCoveragex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Invert.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSampleCoveragex)
}
var _ = atom.Atom(&GlSampleCoveragexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glSampleCoveragexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glSampleCoveragexOES().
func (ϟa *GlSampleCoveragexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glSampleCoveragexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlSampleCoveragexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Invert.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlSampleCoveragexOES)
}
var _ = atom.Atom(&GlScalef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScalef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScalef().
func (ϟa *GlScalef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScalef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScalef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScalef)
}
var _ = atom.Atom(&GlScalex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScalex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScalex().
func (ϟa *GlScalex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScalex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScalex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScalex)
}
var _ = atom.Atom(&GlScalexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glScalexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glScalexOES().
func (ϟa *GlScalexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glScalexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlScalexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlScalexOES)
}
var _ = atom.Atom(&GlShadeModel{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glShadeModel.
// If ϟb is not nil, Mutate also emits the replay instructions to call glShadeModel().
func (ϟa *GlShadeModel) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glShadeModel().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlShadeModel) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlShadeModel)
}
var _ = atom.Atom(&GlTexCoordPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexCoordPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexCoordPointer().
func (ϟa *GlTexCoordPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexCoordPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexCoordPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexCoordPointer)
}
var _ = atom.Atom(&GlTexEnvf{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvf.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvf().
func (ϟa *GlTexEnvf) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvf().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvf) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvf)
}
var _ = atom.Atom(&GlTexEnvfv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvfv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvfv().
func (ϟa *GlTexEnvfv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvfv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvfv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvfv)
}
var _ = atom.Atom(&GlTexEnvi{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvi.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvi().
func (ϟa *GlTexEnvi) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvi().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvi) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvi)
}
var _ = atom.Atom(&GlTexEnviv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnviv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnviv().
func (ϟa *GlTexEnviv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnviv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnviv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnviv)
}
var _ = atom.Atom(&GlTexEnvx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvx().
func (ϟa *GlTexEnvx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvx)
}
var _ = atom.Atom(&GlTexEnvxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvxOES().
func (ϟa *GlTexEnvxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvxOES)
}
var _ = atom.Atom(&GlTexEnvxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvxv().
func (ϟa *GlTexEnvxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvxv)
}
var _ = atom.Atom(&GlTexEnvxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexEnvxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexEnvxvOES().
func (ϟa *GlTexEnvxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexEnvxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexEnvxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexEnvxvOES)
}
var _ = atom.Atom(&GlTexGenfOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGenfOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGenfOES().
func (ϟa *GlTexGenfOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGenfOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGenfOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGenfOES)
}
var _ = atom.Atom(&GlTexGenfvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGenfvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGenfvOES().
func (ϟa *GlTexGenfvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGenfvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGenfvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGenfvOES)
}
var _ = atom.Atom(&GlTexGeniOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGeniOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGeniOES().
func (ϟa *GlTexGeniOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGeniOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGeniOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGeniOES)
}
var _ = atom.Atom(&GlTexGenivOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGenivOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGenivOES().
func (ϟa *GlTexGenivOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGenivOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGenivOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGenivOES)
}
var _ = atom.Atom(&GlTexGenxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGenxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGenxOES().
func (ϟa *GlTexGenxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGenxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGenxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGenxOES)
}
var _ = atom.Atom(&GlTexGenxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexGenxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexGenxvOES().
func (ϟa *GlTexGenxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_texture_cube_map); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexGenxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexGenxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Coord))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexGenxvOES)
}
var _ = atom.Atom(&GlTexParameterx{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterx.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterx().
func (ϟa *GlTexParameterx) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterx().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterx) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterx)
}
var _ = atom.Atom(&GlTexParameterxOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterxOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterxOES().
func (ϟa *GlTexParameterxOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterxOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterxOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Param.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterxOES)
}
var _ = atom.Atom(&GlTexParameterxv{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterxv.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterxv().
func (ϟa *GlTexParameterxv) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterxv().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterxv) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterxv)
}
var _ = atom.Atom(&GlTexParameterxvOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexParameterxvOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexParameterxvOES().
func (ϟa *GlTexParameterxvOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexParameterxvOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexParameterxvOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Pname))
ϟb.Push(ϟa.Params.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexParameterxvOES)
}
var _ = atom.Atom(&GlTranslatef{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTranslatef.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTranslatef().
func (ϟa *GlTranslatef) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTranslatef().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTranslatef) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTranslatef)
}
var _ = atom.Atom(&GlTranslatex{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTranslatex.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTranslatex().
func (ϟa *GlTranslatex) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTranslatex().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTranslatex) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTranslatex)
}
var _ = atom.Atom(&GlTranslatexOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTranslatexOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTranslatexOES().
func (ϟa *GlTranslatexOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_fixed_point); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTranslatexOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTranslatexOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.X.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Y.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Z.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTranslatexOES)
}
var _ = atom.Atom(&GlVertexPointer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexPointer.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexPointer().
func (ϟa *GlVertexPointer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexPointer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexPointer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexPointer)
}
var _ = atom.Atom(&GlWeightPointerOES{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWeightPointerOES.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWeightPointerOES().
func (ϟa *GlWeightPointerOES) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWeightPointerOES().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWeightPointerOES) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWeightPointerOES)
}
var _ = atom.Atom(&GlColorPointerBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glColorPointerBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glColorPointerBounds().
func (ϟa *GlColorPointerBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glColorPointerBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlColorPointerBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlColorPointerBounds)
}
var _ = atom.Atom(&GlNormalPointerBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glNormalPointerBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glNormalPointerBounds().
func (ϟa *GlNormalPointerBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glNormalPointerBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlNormalPointerBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlNormalPointerBounds)
}
var _ = atom.Atom(&GlTexCoordPointerBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glTexCoordPointerBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glTexCoordPointerBounds().
func (ϟa *GlTexCoordPointerBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glTexCoordPointerBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlTexCoordPointerBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexCoordPointerBounds)
}
var _ = atom.Atom(&GlVertexPointerBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glVertexPointerBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glVertexPointerBounds().
func (ϟa *GlVertexPointerBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subMinRequiredVersion(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, GLint(int32(1)), GLint(int32(0))); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glVertexPointerBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlVertexPointerBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexPointerBounds)
}
var _ = atom.Atom(&GlPointSizePointerOESBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glPointSizePointerOESBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glPointSizePointerOESBounds().
func (ϟa *GlPointSizePointerOESBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_point_size_array); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glPointSizePointerOESBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlPointSizePointerOESBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlPointSizePointerOESBounds)
}
var _ = atom.Atom(&GlMatrixIndexPointerOESBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glMatrixIndexPointerOESBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glMatrixIndexPointerOESBounds().
func (ϟa *GlMatrixIndexPointerOESBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glMatrixIndexPointerOESBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlMatrixIndexPointerOESBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlMatrixIndexPointerOESBounds)
}
var _ = atom.Atom(&GlWeightPointerOESBounds{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for glWeightPointerOESBounds.
// If ϟb is not nil, Mutate also emits the replay instructions to call glWeightPointerOESBounds().
func (ϟa *GlWeightPointerOESBounds) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟerr := subRequiresExtension(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb, ExtensionId_GL_OES_matrix_palette); ϟerr != nil {
return ϟerr
}
if ϟerr := subErrorGLES10notSupported(ϟctx, ϟa, ϟo, ϟs, ϟc, ϟd, ϟb); ϟerr != nil {
return ϟerr
}
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke glWeightPointerOESBounds().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *GlWeightPointerOESBounds) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Pointer.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Count.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlWeightPointerOESBounds)
}
var _ = atom.Atom(&ContextInfo{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for contextInfo.
// If ϟb is not nil, Mutate also emits the replay instructions to call contextInfo().
func (ϟa *ContextInfo) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke contextInfo().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *ContextInfo) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.ConstantCount))
ϟb.Push(ϟa.ConstantNames.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ConstantOffsets.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ConstantSizes.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.ConstantData.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BackbufferWidth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BackbufferHeight.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.BackbufferColorFmt))
ϟb.Push(value.U32(ϟa.BackbufferDepthFmt))
ϟb.Push(value.U32(ϟa.BackbufferStencilFmt))
ϟb.Push(value.Bool(ϟa.ResetViewportScissor))
ϟb.Push(value.Bool(ϟa.PreserveBuffersOnSwap))
ϟb.Call(funcInfoContextInfo)
}
var _ = atom.Atom(&ReplayCreateRenderer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for replayCreateRenderer.
// If ϟb is not nil, Mutate also emits the replay instructions to call replayCreateRenderer().
func (ϟa *ReplayCreateRenderer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke replayCreateRenderer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *ReplayCreateRenderer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Id))
ϟb.Call(funcInfoReplayCreateRenderer)
}
var _ = atom.Atom(&ReplayBindRenderer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for replayBindRenderer.
// If ϟb is not nil, Mutate also emits the replay instructions to call replayBindRenderer().
func (ϟa *ReplayBindRenderer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke replayBindRenderer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *ReplayBindRenderer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U32(ϟa.Id))
ϟb.Call(funcInfoReplayBindRenderer)
}
var _ = atom.Atom(&ReplayChangeBackbuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for replayChangeBackbuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call replayChangeBackbuffer().
func (ϟa *ReplayChangeBackbuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke replayChangeBackbuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *ReplayChangeBackbuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(ϟa.BackbufferWidth.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.BackbufferHeight.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.BackbufferColorFmt))
ϟb.Push(value.U32(ϟa.BackbufferDepthFmt))
ϟb.Push(value.U32(ϟa.BackbufferStencilFmt))
ϟb.Push(value.Bool(ϟa.ResetViewportScissor))
ϟb.Call(funcInfoReplayChangeBackbuffer)
}
var _ = atom.Atom(&StartTimer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for startTimer.
// If ϟb is not nil, Mutate also emits the replay instructions to call startTimer().
func (ϟa *StartTimer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke startTimer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *StartTimer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U8(ϟa.Index))
ϟb.Call(funcInfoStartTimer)
}
var _ = atom.Atom(&StopTimer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for stopTimer.
// If ϟb is not nil, Mutate also emits the replay instructions to call stopTimer().
// Upon returning the stopTimer() return value will be stored on the stack.
func (ϟa *StopTimer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
_ = ϟa.Result
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke stopTimer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
// The stopTimer() return value will be stored on the stack.
func (ϟa *StopTimer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Push(value.U8(ϟa.Index))
ϟb.Call(funcInfoStopTimer)
}
var _ = atom.Atom(&FlushPostBuffer{}) // interface compliance check
// Mutate performs the necessary state-mutation and memory observations for flushPostBuffer.
// If ϟb is not nil, Mutate also emits the replay instructions to call flushPostBuffer().
func (ϟa *FlushPostBuffer) Mutate(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) error {
ϟc := GetState(ϟs)
ϟo := ϟa.Extras().Observations()
_ = ϟc
ϟo.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if ϟb != nil {
ϟa.Call(ϟctx, ϟs, ϟd, ϟb)
}
ϟo.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
return nil
}
// Call builds the replay instructions to push the arguments to the stack and invoke flushPostBuffer().
// Unlike Mutate(), Call() does not perform any state-mutation or memory observations to ϟs.
func (ϟa *FlushPostBuffer) Call(ϟctx log.Context, ϟs *gfxapi.State, ϟd database.Database, ϟb *builder.Builder) {
ϟb.Call(funcInfoFlushPostBuffer)
}