blob: ae95e44788bbe6507e81ccdefb6485d49da5627a [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////
package gles
import (
"fmt"
"android.googlesource.com/platform/tools/gpu/atom"
"android.googlesource.com/platform/tools/gpu/database"
"android.googlesource.com/platform/tools/gpu/gfxapi"
"android.googlesource.com/platform/tools/gpu/log"
"android.googlesource.com/platform/tools/gpu/memory"
"android.googlesource.com/platform/tools/gpu/replay"
"android.googlesource.com/platform/tools/gpu/replay/builder"
"android.googlesource.com/platform/tools/gpu/replay/protocol"
"android.googlesource.com/platform/tools/gpu/replay/value"
)
type postCall []func()
func (p *postCall) add(f func()) {
*p = append(*p, f)
}
func (p *postCall) exec() {
for _, f := range *p {
f()
}
}
func loadRemap(ϟb *builder.Builder, key interface{}, val value.Value) {
if ptr, found := ϟb.Remappings[key]; found {
ϟb.Load(val.Type(), ptr)
} else {
ptr = ϟb.AllocateMemory(uint64(val.Type().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
}
}
func storeRemap(ϟb *builder.Builder, key interface{}, val value.Pointer, ty protocol.Type) {
if ptr, found := ϟb.Remappings[key]; !found {
ptr = ϟb.AllocateMemory(uint64(ty.Size(ϟb.Architecture().PointerSize)))
ϟb.Load(ty, val)
ϟb.Store(ptr)
ϟb.Remappings[key] = ptr
}
}
var funcInfoReplayCreateRenderer = builder.FunctionInfo{ID: 0, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoReplayBindRenderer = builder.FunctionInfo{ID: 1, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoBackbufferInfo = builder.FunctionInfo{ID: 2, ReturnType: protocol.TypeVoid, Parameters: 6}
var funcInfoStartTimer = builder.FunctionInfo{ID: 3, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoStopTimer = builder.FunctionInfo{ID: 4, ReturnType: protocol.TypeUint64, Parameters: 1}
var funcInfoFlushPostBuffer = builder.FunctionInfo{ID: 5, ReturnType: protocol.TypeVoid, Parameters: 0}
var funcInfoEglInitialize = builder.FunctionInfo{ID: 6, ReturnType: protocol.TypeInt64, Parameters: 3}
var funcInfoEglCreateContext = builder.FunctionInfo{ID: 7, ReturnType: protocol.TypeVolatilePointer, Parameters: 4}
var funcInfoEglMakeCurrent = builder.FunctionInfo{ID: 8, ReturnType: protocol.TypeInt64, Parameters: 4}
var funcInfoEglSwapBuffers = builder.FunctionInfo{ID: 9, ReturnType: protocol.TypeInt64, Parameters: 2}
var funcInfoEglQuerySurface = builder.FunctionInfo{ID: 10, ReturnType: protocol.TypeInt64, Parameters: 4}
var funcInfoGlXCreateContext = builder.FunctionInfo{ID: 11, ReturnType: protocol.TypeVolatilePointer, Parameters: 4}
var funcInfoGlXCreateNewContext = builder.FunctionInfo{ID: 12, ReturnType: protocol.TypeVolatilePointer, Parameters: 5}
var funcInfoGlXMakeContextCurrent = builder.FunctionInfo{ID: 13, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlXSwapBuffers = builder.FunctionInfo{ID: 14, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoWglCreateContext = builder.FunctionInfo{ID: 15, ReturnType: protocol.TypeVolatilePointer, Parameters: 1}
var funcInfoWglCreateContextAttribsARB = builder.FunctionInfo{ID: 16, ReturnType: protocol.TypeVolatilePointer, Parameters: 3}
var funcInfoWglMakeCurrent = builder.FunctionInfo{ID: 17, ReturnType: protocol.TypeInt64, Parameters: 2}
var funcInfoWglSwapBuffers = builder.FunctionInfo{ID: 18, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoCGLCreateContext = builder.FunctionInfo{ID: 19, ReturnType: protocol.TypeInt64, Parameters: 3}
var funcInfoCGLSetCurrentContext = builder.FunctionInfo{ID: 20, ReturnType: protocol.TypeInt64, Parameters: 1}
var funcInfoGlEnableClientState = builder.FunctionInfo{ID: 21, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDisableClientState = builder.FunctionInfo{ID: 22, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlGetProgramBinaryOES = builder.FunctionInfo{ID: 23, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlProgramBinaryOES = builder.FunctionInfo{ID: 24, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlStartTilingQCOM = builder.FunctionInfo{ID: 25, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlEndTilingQCOM = builder.FunctionInfo{ID: 26, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDiscardFramebufferEXT = builder.FunctionInfo{ID: 27, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlInsertEventMarkerEXT = builder.FunctionInfo{ID: 28, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlPushGroupMarkerEXT = builder.FunctionInfo{ID: 29, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlPopGroupMarkerEXT = builder.FunctionInfo{ID: 30, ReturnType: protocol.TypeVoid, Parameters: 0}
var funcInfoGlTexStorage1DEXT = builder.FunctionInfo{ID: 31, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlTexStorage2DEXT = builder.FunctionInfo{ID: 32, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlTexStorage3DEXT = builder.FunctionInfo{ID: 33, ReturnType: protocol.TypeVoid, Parameters: 6}
var funcInfoGlTextureStorage1DEXT = builder.FunctionInfo{ID: 34, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlTextureStorage2DEXT = builder.FunctionInfo{ID: 35, ReturnType: protocol.TypeVoid, Parameters: 6}
var funcInfoGlTextureStorage3DEXT = builder.FunctionInfo{ID: 36, ReturnType: protocol.TypeVoid, Parameters: 7}
var funcInfoGlGenVertexArraysOES = builder.FunctionInfo{ID: 37, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBindVertexArrayOES = builder.FunctionInfo{ID: 38, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDeleteVertexArraysOES = builder.FunctionInfo{ID: 39, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsVertexArrayOES = builder.FunctionInfo{ID: 40, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlEGLImageTargetTexture2DOES = builder.FunctionInfo{ID: 41, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlEGLImageTargetRenderbufferStorageOES = builder.FunctionInfo{ID: 42, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetGraphicsResetStatusEXT = builder.FunctionInfo{ID: 43, ReturnType: protocol.TypeUint32, Parameters: 0}
var funcInfoGlBindAttribLocation = builder.FunctionInfo{ID: 44, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlBlendFunc = builder.FunctionInfo{ID: 45, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBlendFuncSeparate = builder.FunctionInfo{ID: 46, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlBlendEquation = builder.FunctionInfo{ID: 47, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlBlendEquationSeparate = builder.FunctionInfo{ID: 48, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBlendColor = builder.FunctionInfo{ID: 49, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlEnableVertexAttribArray = builder.FunctionInfo{ID: 50, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDisableVertexAttribArray = builder.FunctionInfo{ID: 51, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlVertexAttribPointer = builder.FunctionInfo{ID: 52, ReturnType: protocol.TypeVoid, Parameters: 6}
var funcInfoGlGetActiveAttrib = builder.FunctionInfo{ID: 53, ReturnType: protocol.TypeVoid, Parameters: 7}
var funcInfoGlGetActiveUniform = builder.FunctionInfo{ID: 54, ReturnType: protocol.TypeVoid, Parameters: 7}
var funcInfoGlGetError = builder.FunctionInfo{ID: 55, ReturnType: protocol.TypeUint32, Parameters: 0}
var funcInfoGlGetProgramiv = builder.FunctionInfo{ID: 56, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetShaderiv = builder.FunctionInfo{ID: 57, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetUniformLocation = builder.FunctionInfo{ID: 58, ReturnType: protocol.TypeInt32, Parameters: 2}
var funcInfoGlGetAttribLocation = builder.FunctionInfo{ID: 59, ReturnType: protocol.TypeUint32, Parameters: 2}
var funcInfoGlPixelStorei = builder.FunctionInfo{ID: 60, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlTexParameteri = builder.FunctionInfo{ID: 61, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlTexParameterf = builder.FunctionInfo{ID: 62, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetTexParameteriv = builder.FunctionInfo{ID: 63, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetTexParameterfv = builder.FunctionInfo{ID: 64, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform1i = builder.FunctionInfo{ID: 65, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlUniform2i = builder.FunctionInfo{ID: 66, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform3i = builder.FunctionInfo{ID: 67, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlUniform4i = builder.FunctionInfo{ID: 68, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlUniform1iv = builder.FunctionInfo{ID: 69, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform2iv = builder.FunctionInfo{ID: 70, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform3iv = builder.FunctionInfo{ID: 71, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform4iv = builder.FunctionInfo{ID: 72, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform1f = builder.FunctionInfo{ID: 73, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlUniform2f = builder.FunctionInfo{ID: 74, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform3f = builder.FunctionInfo{ID: 75, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlUniform4f = builder.FunctionInfo{ID: 76, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlUniform1fv = builder.FunctionInfo{ID: 77, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform2fv = builder.FunctionInfo{ID: 78, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform3fv = builder.FunctionInfo{ID: 79, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniform4fv = builder.FunctionInfo{ID: 80, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlUniformMatrix2fv = builder.FunctionInfo{ID: 81, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlUniformMatrix3fv = builder.FunctionInfo{ID: 82, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlUniformMatrix4fv = builder.FunctionInfo{ID: 83, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlGetUniformfv = builder.FunctionInfo{ID: 84, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetUniformiv = builder.FunctionInfo{ID: 85, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlVertexAttrib1f = builder.FunctionInfo{ID: 86, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlVertexAttrib2f = builder.FunctionInfo{ID: 87, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlVertexAttrib3f = builder.FunctionInfo{ID: 88, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlVertexAttrib4f = builder.FunctionInfo{ID: 89, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlVertexAttrib1fv = builder.FunctionInfo{ID: 90, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlVertexAttrib2fv = builder.FunctionInfo{ID: 91, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlVertexAttrib3fv = builder.FunctionInfo{ID: 92, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlVertexAttrib4fv = builder.FunctionInfo{ID: 93, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetShaderPrecisionFormat = builder.FunctionInfo{ID: 94, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlDepthMask = builder.FunctionInfo{ID: 95, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDepthFunc = builder.FunctionInfo{ID: 96, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDepthRangef = builder.FunctionInfo{ID: 97, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlColorMask = builder.FunctionInfo{ID: 98, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlStencilMask = builder.FunctionInfo{ID: 99, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlStencilMaskSeparate = builder.FunctionInfo{ID: 100, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlStencilFuncSeparate = builder.FunctionInfo{ID: 101, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlStencilOpSeparate = builder.FunctionInfo{ID: 102, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlFrontFace = builder.FunctionInfo{ID: 103, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlViewport = builder.FunctionInfo{ID: 104, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlScissor = builder.FunctionInfo{ID: 105, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlActiveTexture = builder.FunctionInfo{ID: 106, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlGenTextures = builder.FunctionInfo{ID: 107, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlDeleteTextures = builder.FunctionInfo{ID: 108, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsTexture = builder.FunctionInfo{ID: 109, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlBindTexture = builder.FunctionInfo{ID: 110, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlTexImage2D = builder.FunctionInfo{ID: 111, ReturnType: protocol.TypeVoid, Parameters: 9}
var funcInfoGlTexSubImage2D = builder.FunctionInfo{ID: 112, ReturnType: protocol.TypeVoid, Parameters: 9}
var funcInfoGlCopyTexImage2D = builder.FunctionInfo{ID: 113, ReturnType: protocol.TypeVoid, Parameters: 8}
var funcInfoGlCopyTexSubImage2D = builder.FunctionInfo{ID: 114, ReturnType: protocol.TypeVoid, Parameters: 8}
var funcInfoGlCompressedTexImage2D = builder.FunctionInfo{ID: 115, ReturnType: protocol.TypeVoid, Parameters: 8}
var funcInfoGlCompressedTexSubImage2D = builder.FunctionInfo{ID: 116, ReturnType: protocol.TypeVoid, Parameters: 9}
var funcInfoGlGenerateMipmap = builder.FunctionInfo{ID: 117, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlReadPixels = builder.FunctionInfo{ID: 118, ReturnType: protocol.TypeVoid, Parameters: 7}
var funcInfoGlGenFramebuffers = builder.FunctionInfo{ID: 119, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBindFramebuffer = builder.FunctionInfo{ID: 120, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlCheckFramebufferStatus = builder.FunctionInfo{ID: 121, ReturnType: protocol.TypeUint32, Parameters: 1}
var funcInfoGlDeleteFramebuffers = builder.FunctionInfo{ID: 122, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsFramebuffer = builder.FunctionInfo{ID: 123, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlGenRenderbuffers = builder.FunctionInfo{ID: 124, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBindRenderbuffer = builder.FunctionInfo{ID: 125, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlRenderbufferStorage = builder.FunctionInfo{ID: 126, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlDeleteRenderbuffers = builder.FunctionInfo{ID: 127, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsRenderbuffer = builder.FunctionInfo{ID: 128, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlGetRenderbufferParameteriv = builder.FunctionInfo{ID: 129, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGenBuffers = builder.FunctionInfo{ID: 130, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBindBuffer = builder.FunctionInfo{ID: 131, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBufferData = builder.FunctionInfo{ID: 132, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlBufferSubData = builder.FunctionInfo{ID: 133, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlDeleteBuffers = builder.FunctionInfo{ID: 134, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsBuffer = builder.FunctionInfo{ID: 135, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlGetBufferParameteriv = builder.FunctionInfo{ID: 136, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlCreateShader = builder.FunctionInfo{ID: 137, ReturnType: protocol.TypeUint32, Parameters: 1}
var funcInfoGlDeleteShader = builder.FunctionInfo{ID: 138, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlShaderSource = builder.FunctionInfo{ID: 139, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlShaderBinary = builder.FunctionInfo{ID: 140, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlGetShaderInfoLog = builder.FunctionInfo{ID: 141, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlGetShaderSource = builder.FunctionInfo{ID: 142, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlReleaseShaderCompiler = builder.FunctionInfo{ID: 143, ReturnType: protocol.TypeVoid, Parameters: 0}
var funcInfoGlCompileShader = builder.FunctionInfo{ID: 144, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlIsShader = builder.FunctionInfo{ID: 145, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlCreateProgram = builder.FunctionInfo{ID: 146, ReturnType: protocol.TypeUint32, Parameters: 0}
var funcInfoGlDeleteProgram = builder.FunctionInfo{ID: 147, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlAttachShader = builder.FunctionInfo{ID: 148, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlDetachShader = builder.FunctionInfo{ID: 149, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetAttachedShaders = builder.FunctionInfo{ID: 150, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlLinkProgram = builder.FunctionInfo{ID: 151, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlGetProgramInfoLog = builder.FunctionInfo{ID: 152, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlUseProgram = builder.FunctionInfo{ID: 153, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlIsProgram = builder.FunctionInfo{ID: 154, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlValidateProgram = builder.FunctionInfo{ID: 155, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlClearColor = builder.FunctionInfo{ID: 156, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlClearDepthf = builder.FunctionInfo{ID: 157, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlClearStencil = builder.FunctionInfo{ID: 158, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlClear = builder.FunctionInfo{ID: 159, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlCullFace = builder.FunctionInfo{ID: 160, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlPolygonOffset = builder.FunctionInfo{ID: 161, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlLineWidth = builder.FunctionInfo{ID: 162, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlSampleCoverage = builder.FunctionInfo{ID: 163, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlHint = builder.FunctionInfo{ID: 164, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlFramebufferRenderbuffer = builder.FunctionInfo{ID: 165, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlFramebufferTexture2D = builder.FunctionInfo{ID: 166, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlGetFramebufferAttachmentParameteriv = builder.FunctionInfo{ID: 167, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlDrawElements = builder.FunctionInfo{ID: 168, ReturnType: protocol.TypeVoid, Parameters: 4}
var funcInfoGlDrawArrays = builder.FunctionInfo{ID: 169, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlFlush = builder.FunctionInfo{ID: 170, ReturnType: protocol.TypeVoid, Parameters: 0}
var funcInfoGlFinish = builder.FunctionInfo{ID: 171, ReturnType: protocol.TypeVoid, Parameters: 0}
var funcInfoGlGetBooleanv = builder.FunctionInfo{ID: 172, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetFloatv = builder.FunctionInfo{ID: 173, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetIntegerv = builder.FunctionInfo{ID: 174, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetString = builder.FunctionInfo{ID: 175, ReturnType: protocol.TypeVolatilePointer, Parameters: 1}
var funcInfoGlEnable = builder.FunctionInfo{ID: 176, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDisable = builder.FunctionInfo{ID: 177, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlIsEnabled = builder.FunctionInfo{ID: 178, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlMapBufferRange = builder.FunctionInfo{ID: 179, ReturnType: protocol.TypeVolatilePointer, Parameters: 4}
var funcInfoGlUnmapBuffer = builder.FunctionInfo{ID: 180, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlInvalidateFramebuffer = builder.FunctionInfo{ID: 181, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlRenderbufferStorageMultisample = builder.FunctionInfo{ID: 182, ReturnType: protocol.TypeVoid, Parameters: 5}
var funcInfoGlBlitFramebuffer = builder.FunctionInfo{ID: 183, ReturnType: protocol.TypeVoid, Parameters: 10}
var funcInfoGlGenQueries = builder.FunctionInfo{ID: 184, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBeginQuery = builder.FunctionInfo{ID: 185, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlEndQuery = builder.FunctionInfo{ID: 186, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDeleteQueries = builder.FunctionInfo{ID: 187, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsQuery = builder.FunctionInfo{ID: 188, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlGetQueryiv = builder.FunctionInfo{ID: 189, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetQueryObjectuiv = builder.FunctionInfo{ID: 190, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGenQueriesEXT = builder.FunctionInfo{ID: 191, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlBeginQueryEXT = builder.FunctionInfo{ID: 192, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlEndQueryEXT = builder.FunctionInfo{ID: 193, ReturnType: protocol.TypeVoid, Parameters: 1}
var funcInfoGlDeleteQueriesEXT = builder.FunctionInfo{ID: 194, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlIsQueryEXT = builder.FunctionInfo{ID: 195, ReturnType: protocol.TypeBool, Parameters: 1}
var funcInfoGlQueryCounterEXT = builder.FunctionInfo{ID: 196, ReturnType: protocol.TypeVoid, Parameters: 2}
var funcInfoGlGetQueryivEXT = builder.FunctionInfo{ID: 197, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetQueryObjectivEXT = builder.FunctionInfo{ID: 198, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetQueryObjectuivEXT = builder.FunctionInfo{ID: 199, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetQueryObjecti64vEXT = builder.FunctionInfo{ID: 200, ReturnType: protocol.TypeVoid, Parameters: 3}
var funcInfoGlGetQueryObjectui64vEXT = builder.FunctionInfo{ID: 201, ReturnType: protocol.TypeVoid, Parameters: 3}
func (c RenderbufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c TextureId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c FramebufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c BufferId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c ShaderId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c ProgramId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c VertexArrayId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c QueryId) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
func (c UniformLocation) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S32(int32(c))
}
func (c AttributeLocation) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.U32(uint32(c))
}
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.U32(uint32(c))
}
func (c EGLBoolean) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c EGLint) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c EGLConfig) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c EGLContext) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c EGLDisplay) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c EGLSurface) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c GLXContext) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c GLXDrawable) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c HGLRC) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c HDC) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c BOOL) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c CGLError) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return value.S64(int64(c))
}
func (c CGLPixelFormatObj) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
func (c CGLContextObj) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value {
return Voidᵖ(c).value()
}
var _ = replay.Replayer(&ReplayCreateRenderer{}) // interface compliance check
func (ϟa *ReplayCreateRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Id))
ϟb.Call(funcInfoReplayCreateRenderer)
ϟp.exec()
}
var _ = replay.Replayer(&ReplayBindRenderer{}) // interface compliance check
func (ϟa *ReplayBindRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Id))
ϟb.Call(funcInfoReplayBindRenderer)
ϟp.exec()
}
var _ = replay.Replayer(&BackbufferInfo{}) // interface compliance check
func (ϟa *BackbufferInfo) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_0_result := context // Contextʳ
ctx := GetContext_0_result // Contextʳ
backbuffer := ctx.Instances.Framebuffers.Get(FramebufferId(uint32(0))) // Framebufferʳ
color_id := RenderbufferId(backbuffer.Attachments.Get(FramebufferAttachment_GL_COLOR_ATTACHMENT0).Object) // RenderbufferId
color_buffer := ctx.Instances.Renderbuffers.Get(color_id) // Renderbufferʳ
depth_id := RenderbufferId(backbuffer.Attachments.Get(FramebufferAttachment_GL_DEPTH_ATTACHMENT).Object) // RenderbufferId
depth_buffer := ctx.Instances.Renderbuffers.Get(depth_id) // Renderbufferʳ
stencil_id := RenderbufferId(backbuffer.Attachments.Get(FramebufferAttachment_GL_STENCIL_ATTACHMENT).Object) // RenderbufferId
stencil_buffer := ctx.Instances.Renderbuffers.Get(stencil_id) // Renderbufferʳ
color_buffer.Width = ϟa.Width
color_buffer.Height = ϟa.Height
color_buffer.Format = ϟa.ColorFmt
depth_buffer.Width = ϟa.Width
depth_buffer.Height = ϟa.Height
depth_buffer.Format = ϟa.DepthFmt
stencil_buffer.Width = ϟa.Width
stencil_buffer.Height = ϟa.Height
stencil_buffer.Format = ϟa.StencilFmt
if ϟa.ResetViewportScissor {
ctx.Rasterizing.Scissor.Width = ϟa.Width
ctx.Rasterizing.Scissor.Height = ϟa.Height
ctx.Rasterizing.Viewport.Width = ϟa.Width
ctx.Rasterizing.Viewport.Height = ϟa.Height
}
_, _, _, _, _, _, _, _, _, _ = context, GetContext_0_result, ctx, backbuffer, color_id, color_buffer, depth_id, depth_buffer, stencil_id, stencil_buffer
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.U32(ϟa.ColorFmt))
ϟb.Push(value.U32(ϟa.DepthFmt))
ϟb.Push(value.U32(ϟa.StencilFmt))
ϟb.Push(value.Bool(ϟa.ResetViewportScissor))
ϟb.Call(funcInfoBackbufferInfo)
ϟp.exec()
}
var _ = replay.Replayer(&StartTimer{}) // interface compliance check
func (ϟa *StartTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U8(ϟa.Index))
ϟb.Call(funcInfoStartTimer)
ϟp.exec()
}
var _ = replay.Replayer(&StopTimer{}) // interface compliance check
func (ϟa *StopTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U8(ϟa.Index))
ϟb.Call(funcInfoStopTimer)
ϟp.exec()
}
var _ = replay.Replayer(&FlushPostBuffer{}) // interface compliance check
func (ϟa *FlushPostBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoFlushPostBuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlEnableClientState{}) // interface compliance check
func (ϟa *GlEnableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_11_result := context // Contextʳ
ctx := GetContext_11_result // Contextʳ
ctx.Capabilities[Capability(ϟa.Type)] = true
_, _, _ = context, GetContext_11_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Type))
ϟb.Call(funcInfoGlEnableClientState)
ϟp.exec()
}
var _ = replay.Replayer(&GlDisableClientState{}) // interface compliance check
func (ϟa *GlDisableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_12_result := context // Contextʳ
ctx := GetContext_12_result // Contextʳ
ctx.Capabilities[Capability(ϟa.Type)] = false
_, _, _ = context, GetContext_12_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Type))
ϟb.Call(funcInfoGlDisableClientState)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetProgramBinaryOES{}) // interface compliance check
func (ϟa *GlGetProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
l := int32(ϟa.BytesWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // s32
ϟa.BytesWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(l, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.BinaryFormat.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(ϟa.BinaryFormat.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.Binary.Slice(uint64(int32(0)), uint64(l), ϟs).onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = l
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.BufferSize))
ϟb.Push(ϟa.BytesWritten.value())
ϟb.Push(ϟa.BinaryFormat.value())
ϟb.Push(ϟa.Binary.value())
ϟb.Call(funcInfoGlGetProgramBinaryOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlProgramBinaryOES{}) // interface compliance check
func (ϟa *GlProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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.Push(value.S32(ϟa.BinarySize))
ϟb.Call(funcInfoGlProgramBinaryOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlStartTilingQCOM{}) // interface compliance check
func (ϟa *GlStartTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.U32(ϟa.PreserveMask))
ϟb.Call(funcInfoGlStartTilingQCOM)
ϟp.exec()
}
var _ = replay.Replayer(&GlEndTilingQCOM{}) // interface compliance check
func (ϟa *GlEndTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.PreserveMask))
ϟb.Call(funcInfoGlEndTilingQCOM)
ϟp.exec()
}
var _ = replay.Replayer(&GlDiscardFramebufferEXT{}) // interface compliance check
func (ϟa *GlDiscardFramebufferEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.NumAttachments))
ϟb.Push(ϟa.Attachments.value())
ϟb.Call(funcInfoGlDiscardFramebufferEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlInsertEventMarkerEXT{}) // interface compliance check
func (ϟa *GlInsertEventMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Length))
ϟb.Push(ϟb.String(ϟa.Marker))
ϟb.Call(funcInfoGlInsertEventMarkerEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlPushGroupMarkerEXT{}) // interface compliance check
func (ϟa *GlPushGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Length))
ϟb.Push(ϟb.String(ϟa.Marker))
ϟb.Call(funcInfoGlPushGroupMarkerEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlPopGroupMarkerEXT{}) // interface compliance check
func (ϟa *GlPopGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoGlPopGroupMarkerEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexStorage1DEXT{}) // interface compliance check
func (ϟa *GlTexStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Call(funcInfoGlTexStorage1DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexStorage2DEXT{}) // interface compliance check
func (ϟa *GlTexStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlTexStorage2DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexStorage3DEXT{}) // interface compliance check
func (ϟa *GlTexStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.S32(ϟa.Depth))
ϟb.Call(funcInfoGlTexStorage3DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTextureStorage1DEXT{}) // interface compliance check
func (ϟa *GlTextureStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Call(funcInfoGlTextureStorage1DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTextureStorage2DEXT{}) // interface compliance check
func (ϟa *GlTextureStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlTextureStorage2DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlTextureStorage3DEXT{}) // interface compliance check
func (ϟa *GlTextureStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Levels))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.S32(ϟa.Depth))
ϟb.Call(funcInfoGlTextureStorage3DEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenVertexArraysOES{}) // interface compliance check
func (ϟa *GlGenVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
a := ϟa.Arrays.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // VertexArrayIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_13_result := context // Contextʳ
ctx := GetContext_13_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
id := VertexArrayId(ϟa.Arrays.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // VertexArrayId
ctx.Instances.VertexArrays[id] = func() *VertexArray {
s := &VertexArray{}
s.Init()
return s
}()
a.Index(uint64(i), ϟs).replayWrite(id, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = id
}
_, _, _, _ = a, context, GetContext_13_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Arrays.value())
ϟb.Call(funcInfoGlGenVertexArraysOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindVertexArrayOES{}) // interface compliance check
func (ϟa *GlBindVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_14_result := context // Contextʳ
ctx := GetContext_14_result // Contextʳ
if !(ctx.Instances.VertexArrays.Contains(ϟa.Array)) {
ctx.Instances.VertexArrays[ϟa.Array] = func() *VertexArray {
s := &VertexArray{}
s.Init()
return s
}()
}
ctx.BoundVertexArray = ϟa.Array
_, _, _ = context, GetContext_14_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindVertexArrayOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteVertexArraysOES{}) // interface compliance check
func (ϟa *GlDeleteVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_15_result := context // Contextʳ
ctx := GetContext_15_result // Contextʳ
a := ϟa.Arrays.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // VertexArrayIdˢ
for i := int32(int32(0)); i < ϟa.Count; i++ {
ctx.Instances.VertexArrays[a.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)] = (*VertexArray)(nil)
}
_, _, _, _ = context, GetContext_15_result, ctx, a
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Arrays.value())
ϟb.Call(funcInfoGlDeleteVertexArraysOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsVertexArrayOES{}) // interface compliance check
func (ϟa *GlIsVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_16_result := context // Contextʳ
ctx := GetContext_16_result // Contextʳ
ϟa.Result = ctx.Instances.VertexArrays.Contains(ϟa.Array)
_, _, _ = context, GetContext_16_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Array.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Array.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Array.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsVertexArrayOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlEGLImageTargetTexture2DOES{}) // interface compliance check
func (ϟa *GlEGLImageTargetTexture2DOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Image.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEGLImageTargetTexture2DOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlEGLImageTargetRenderbufferStorageOES{}) // interface compliance check
func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(ϟa.Image.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEGLImageTargetRenderbufferStorageOES)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetGraphicsResetStatusEXT{}) // interface compliance check
func (ϟa *GlGetGraphicsResetStatusEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoGlGetGraphicsResetStatusEXT)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindAttribLocation{}) // interface compliance check
func (ϟa *GlBindAttribLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_17_result := context // Contextʳ
ctx := GetContext_17_result // Contextʳ
p := ctx.Instances.Programs.Get(ϟa.Program) // Programʳ
p.AttributeBindings[ϟa.Name] = ϟa.Location
_, _, _, _ = context, GetContext_17_result, ctx, p
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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)
ϟp.exec()
}
var _ = replay.Replayer(&GlBlendFunc{}) // interface compliance check
func (ϟa *GlBlendFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_18_result := context // Contextʳ
ctx := GetContext_18_result // Contextʳ
ctx.Blending.SrcRgbBlendFactor = ϟa.SrcFactor
ctx.Blending.SrcAlphaBlendFactor = ϟa.SrcFactor
ctx.Blending.DstRgbBlendFactor = ϟa.DstFactor
ctx.Blending.DstAlphaBlendFactor = ϟa.DstFactor
_, _, _ = context, GetContext_18_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.SrcFactor))
ϟb.Push(value.U32(ϟa.DstFactor))
ϟb.Call(funcInfoGlBlendFunc)
ϟp.exec()
}
var _ = replay.Replayer(&GlBlendFuncSeparate{}) // interface compliance check
func (ϟa *GlBlendFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_19_result := context // Contextʳ
ctx := GetContext_19_result // Contextʳ
ctx.Blending.SrcRgbBlendFactor = ϟa.SrcFactorRgb
ctx.Blending.DstRgbBlendFactor = ϟa.DstFactorRgb
ctx.Blending.SrcAlphaBlendFactor = ϟa.SrcFactorAlpha
ctx.Blending.DstAlphaBlendFactor = ϟa.DstFactorAlpha
_, _, _ = context, GetContext_19_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟ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)
ϟp.exec()
}
var _ = replay.Replayer(&GlBlendEquation{}) // interface compliance check
func (ϟa *GlBlendEquation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_20_result := context // Contextʳ
ctx := GetContext_20_result // Contextʳ
ctx.Blending.BlendEquationRgb = ϟa.Equation
ctx.Blending.BlendEquationAlpha = ϟa.Equation
_, _, _ = context, GetContext_20_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Equation))
ϟb.Call(funcInfoGlBlendEquation)
ϟp.exec()
}
var _ = replay.Replayer(&GlBlendEquationSeparate{}) // interface compliance check
func (ϟa *GlBlendEquationSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_21_result := context // Contextʳ
ctx := GetContext_21_result // Contextʳ
ctx.Blending.BlendEquationRgb = ϟa.Rgb
ctx.Blending.BlendEquationAlpha = ϟa.Alpha
_, _, _ = context, GetContext_21_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Rgb))
ϟb.Push(value.U32(ϟa.Alpha))
ϟb.Call(funcInfoGlBlendEquationSeparate)
ϟp.exec()
}
var _ = replay.Replayer(&GlBlendColor{}) // interface compliance check
func (ϟa *GlBlendColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_22_result := context // Contextʳ
ctx := GetContext_22_result // Contextʳ
ctx.Blending.BlendColor = func() Color {
s := Color{}
s.Init()
s.Red = ϟa.Red
s.Green = ϟa.Green
s.Blue = ϟa.Blue
s.Alpha = ϟa.Alpha
return s
}()
_, _, _ = context, GetContext_22_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.Red))
ϟb.Push(value.F32(ϟa.Green))
ϟb.Push(value.F32(ϟa.Blue))
ϟb.Push(value.F32(ϟa.Alpha))
ϟb.Call(funcInfoGlBlendColor)
ϟp.exec()
}
var _ = replay.Replayer(&GlEnableVertexAttribArray{}) // interface compliance check
func (ϟa *GlEnableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_23_result := context // Contextʳ
ctx := GetContext_23_result // Contextʳ
ctx.VertexAttributeArrays.Get(ϟa.Location).Enabled = true
_, _, _ = context, GetContext_23_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlEnableVertexAttribArray)
ϟp.exec()
}
var _ = replay.Replayer(&GlDisableVertexAttribArray{}) // interface compliance check
func (ϟa *GlDisableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_24_result := context // Contextʳ
ctx := GetContext_24_result // Contextʳ
ctx.VertexAttributeArrays.Get(ϟa.Location).Enabled = false
_, _, _ = context, GetContext_24_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlDisableVertexAttribArray)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttribPointer{}) // interface compliance check
func (ϟa *GlVertexAttribPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_25_result := context // Contextʳ
ctx := GetContext_25_result // Contextʳ
a := ctx.VertexAttributeArrays.Get(ϟa.Location) // VertexAttributeArrayʳ
a.Size = uint32(ϟa.Size)
a.Type = ϟa.Type
a.Normalized = ϟa.Normalized
a.Stride = ϟa.Stride
a.Pointer = ϟa.Data
a.Buffer = ctx.BoundBuffers.Get(BufferTarget_GL_ARRAY_BUFFER)
_, _, _, _ = context, GetContext_25_result, ctx, a
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.S32(ϟa.Size))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(value.Bool(ϟa.Normalized))
ϟb.Push(value.S32(ϟa.Stride))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlVertexAttribPointer)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetActiveAttrib{}) // interface compliance check
func (ϟa *GlGetActiveAttrib) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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.S32(ϟa.BufferSize))
ϟb.Push(ϟa.BufferBytesWritten.value())
ϟb.Push(ϟa.VectorCount.value())
ϟb.Push(ϟa.Type.value())
ϟb.Push(ϟa.Name.value())
ϟb.Call(funcInfoGlGetActiveAttrib)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetActiveUniform{}) // interface compliance check
func (ϟa *GlGetActiveUniform) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Location))
ϟb.Push(value.S32(ϟa.BufferSize))
ϟb.Push(ϟa.BufferBytesWritten.value())
ϟb.Push(ϟa.Size.value())
ϟb.Push(ϟa.Type.value())
ϟb.Push(ϟa.Name.value())
ϟb.Call(funcInfoGlGetActiveUniform)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetError{}) // interface compliance check
func (ϟa *GlGetError) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoGlGetError)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetProgramiv{}) // interface compliance check
func (ϟa *GlGetProgramiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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.Call(funcInfoGlGetProgramiv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetShaderiv{}) // interface compliance check
func (ϟa *GlGetShaderiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_26_result := context // Contextʳ
ctx := GetContext_26_result // Contextʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(func() (result int32) {
switch ϟa.Parameter {
case ShaderParameter_GL_SHADER_TYPE:
return int32(s.Type)
case ShaderParameter_GL_DELETE_STATUS:
return func() (result int32) {
switch s.Deletable {
case true:
return int32(1)
case false:
return int32(0)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", s.Deletable, ϟa))
return result
}
}()
case ShaderParameter_GL_COMPILE_STATUS:
return func() (result int32) {
switch s.Compiled {
case true:
return int32(1)
case false:
return int32(0)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", s.Compiled, ϟa))
return result
}
}()
case ShaderParameter_GL_INFO_LOG_LENGTH:
return int32(externs{ϟs, ϟd, ϟl}.strlen(s.InfoLog))
case ShaderParameter_GL_SHADER_SOURCE_LENGTH:
return int32(externs{ϟs, ϟd, ϟl}.strlen(s.Source))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _ = context, GetContext_26_result, ctx, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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.Call(funcInfoGlGetShaderiv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetUniformLocation{}) // interface compliance check
func (ϟa *GlGetUniformLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetUniformLocation)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetAttribLocation{}) // interface compliance check
func (ϟa *GlGetAttribLocation) defaultReplay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟb.String(ϟa.Name))
ϟb.Call(funcInfoGlGetAttribLocation)
ϟp.exec()
}
var _ = replay.Replayer(&GlPixelStorei{}) // interface compliance check
func (ϟa *GlPixelStorei) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_27_result := context // Contextʳ
ctx := GetContext_27_result // Contextʳ
ctx.PixelStorage[ϟa.Parameter] = ϟa.Value
_, _, _ = context, GetContext_27_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(value.S32(ϟa.Value))
ϟb.Call(funcInfoGlPixelStorei)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexParameteri{}) // interface compliance check
func (ϟa *GlTexParameteri) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_28_result := context // Contextʳ
ctx := GetContext_28_result // Contextʳ
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(ϟa.Target) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
switch ϟa.Parameter {
case TextureParameter_GL_TEXTURE_MAG_FILTER:
t.MagFilter = TextureFilterMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_MIN_FILTER:
t.MinFilter = TextureFilterMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_WRAP_S:
t.WrapS = TextureWrapMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_WRAP_T:
t.WrapT = TextureWrapMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_MAX_ANISOTROPY_EXT:
t.MaxAnisotropy = float32(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_R:
t.SwizzleR = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_G:
t.SwizzleG = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_B:
t.SwizzleB = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_A:
t.SwizzleA = TexelComponent(ϟa.Value)
default:
// TODO: better unmatched handling
v := ϟa.Parameter
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _, _, _ = context, GetContext_28_result, ctx, id, t
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(value.S32(ϟa.Value))
ϟb.Call(funcInfoGlTexParameteri)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexParameterf{}) // interface compliance check
func (ϟa *GlTexParameterf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_29_result := context // Contextʳ
ctx := GetContext_29_result // Contextʳ
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(ϟa.Target) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
switch ϟa.Parameter {
case TextureParameter_GL_TEXTURE_MAG_FILTER:
t.MagFilter = TextureFilterMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_MIN_FILTER:
t.MinFilter = TextureFilterMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_WRAP_S:
t.WrapS = TextureWrapMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_WRAP_T:
t.WrapT = TextureWrapMode(ϟa.Value)
case TextureParameter_GL_TEXTURE_MAX_ANISOTROPY_EXT:
t.MaxAnisotropy = ϟa.Value
case TextureParameter_GL_TEXTURE_SWIZZLE_R:
t.SwizzleR = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_G:
t.SwizzleG = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_B:
t.SwizzleB = TexelComponent(ϟa.Value)
case TextureParameter_GL_TEXTURE_SWIZZLE_A:
t.SwizzleA = TexelComponent(ϟa.Value)
default:
// TODO: better unmatched handling
v := ϟa.Parameter
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _, _, _ = context, GetContext_29_result, ctx, id, t
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(value.F32(ϟa.Value))
ϟb.Call(funcInfoGlTexParameterf)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetTexParameteriv{}) // interface compliance check
func (ϟa *GlGetTexParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_30_result := context // Contextʳ
ctx := GetContext_30_result // Contextʳ
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(ϟa.Target) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
ϟa.Values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(func() (result int32) {
switch ϟa.Parameter {
case TextureParameter_GL_TEXTURE_MAG_FILTER:
return int32(t.MagFilter)
case TextureParameter_GL_TEXTURE_MIN_FILTER:
return int32(t.MinFilter)
case TextureParameter_GL_TEXTURE_WRAP_S:
return int32(t.WrapS)
case TextureParameter_GL_TEXTURE_WRAP_T:
return int32(t.WrapT)
case TextureParameter_GL_TEXTURE_MAX_ANISOTROPY_EXT:
return int32(t.MaxAnisotropy)
case TextureParameter_GL_TEXTURE_SWIZZLE_R:
return int32(t.SwizzleR)
case TextureParameter_GL_TEXTURE_SWIZZLE_G:
return int32(t.SwizzleG)
case TextureParameter_GL_TEXTURE_SWIZZLE_B:
return int32(t.SwizzleB)
case TextureParameter_GL_TEXTURE_SWIZZLE_A:
return int32(t.SwizzleA)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _ = context, GetContext_30_result, ctx, id, t
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlGetTexParameteriv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetTexParameterfv{}) // interface compliance check
func (ϟa *GlGetTexParameterfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_31_result := context // Contextʳ
ctx := GetContext_31_result // Contextʳ
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(ϟa.Target) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
ϟa.Values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(func() (result float32) {
switch ϟa.Parameter {
case TextureParameter_GL_TEXTURE_MAG_FILTER:
return float32(t.MagFilter)
case TextureParameter_GL_TEXTURE_MIN_FILTER:
return float32(t.MinFilter)
case TextureParameter_GL_TEXTURE_WRAP_S:
return float32(t.WrapS)
case TextureParameter_GL_TEXTURE_WRAP_T:
return float32(t.WrapT)
case TextureParameter_GL_TEXTURE_MAX_ANISOTROPY_EXT:
return t.MaxAnisotropy
case TextureParameter_GL_TEXTURE_SWIZZLE_R:
return float32(t.SwizzleR)
case TextureParameter_GL_TEXTURE_SWIZZLE_G:
return float32(t.SwizzleG)
case TextureParameter_GL_TEXTURE_SWIZZLE_B:
return float32(t.SwizzleB)
case TextureParameter_GL_TEXTURE_SWIZZLE_A:
return float32(t.SwizzleA)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _ = context, GetContext_31_result, ctx, id, t
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlGetTexParameterfv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform1i{}) // interface compliance check
func (ϟa *GlUniform1i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_32_result := context // Contextʳ
ctx := GetContext_32_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT
uniform.Value.S32 = ϟa.Value
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_32_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Value))
ϟb.Call(funcInfoGlUniform1i)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform2i{}) // interface compliance check
func (ϟa *GlUniform2i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_33_result := context // Contextʳ
ctx := GetContext_33_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC2
uniform.Value.Vec2i = func() Vec2i {
s := Vec2i{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_33_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Value0))
ϟb.Push(value.S32(ϟa.Value1))
ϟb.Call(funcInfoGlUniform2i)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform3i{}) // interface compliance check
func (ϟa *GlUniform3i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_34_result := context // Contextʳ
ctx := GetContext_34_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC3
uniform.Value.Vec3i = func() Vec3i {
s := Vec3i{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
s.Z = ϟa.Value2
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_34_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Value0))
ϟb.Push(value.S32(ϟa.Value1))
ϟb.Push(value.S32(ϟa.Value2))
ϟb.Call(funcInfoGlUniform3i)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform4i{}) // interface compliance check
func (ϟa *GlUniform4i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_35_result := context // Contextʳ
ctx := GetContext_35_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC4
uniform.Value.Vec4i = func() Vec4i {
s := Vec4i{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
s.Z = ϟa.Value2
s.W = ϟa.Value3
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_35_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Value0))
ϟb.Push(value.S32(ϟa.Value1))
ϟb.Push(value.S32(ϟa.Value2))
ϟb.Push(value.S32(ϟa.Value3))
ϟb.Call(funcInfoGlUniform4i)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform1iv{}) // interface compliance check
func (ϟa *GlUniform1iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_36_result := context // Contextʳ
ctx := GetContext_36_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT
uniform.Value.S32 = ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_36_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform1iv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform2iv{}) // interface compliance check
func (ϟa *GlUniform2iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_37_result := context // Contextʳ
ctx := GetContext_37_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(2))), ϟs) // S32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC2
uniform.Value.Vec2i = func() Vec2i {
s := Vec2i{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_37_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform2iv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform3iv{}) // interface compliance check
func (ϟa *GlUniform3iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_38_result := context // Contextʳ
ctx := GetContext_38_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(3))), ϟs) // S32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC3
uniform.Value.Vec3i = func() Vec3i {
s := Vec3i{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_38_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform3iv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform4iv{}) // interface compliance check
func (ϟa *GlUniform4iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_39_result := context // Contextʳ
ctx := GetContext_39_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(4))), ϟs) // S32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_INT_VEC4
uniform.Value.Vec4i = func() Vec4i {
s := Vec4i{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(3), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_39_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform4iv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform1f{}) // interface compliance check
func (ϟa *GlUniform1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_40_result := context // Contextʳ
ctx := GetContext_40_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT
uniform.Value.F32 = ϟa.Value
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_40_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.F32(ϟa.Value))
ϟb.Call(funcInfoGlUniform1f)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform2f{}) // interface compliance check
func (ϟa *GlUniform2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_41_result := context // Contextʳ
ctx := GetContext_41_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC2
uniform.Value.Vec2f = func() Vec2f {
s := Vec2f{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_41_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Call(funcInfoGlUniform2f)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform3f{}) // interface compliance check
func (ϟa *GlUniform3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_42_result := context // Contextʳ
ctx := GetContext_42_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC3
uniform.Value.Vec3f = func() Vec3f {
s := Vec3f{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
s.Z = ϟa.Value2
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_42_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Push(value.F32(ϟa.Value2))
ϟb.Call(funcInfoGlUniform3f)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform4f{}) // interface compliance check
func (ϟa *GlUniform4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_43_result := context // Contextʳ
ctx := GetContext_43_result // Contextʳ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC4
uniform.Value.Vec4f = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = ϟa.Value0
s.Y = ϟa.Value1
s.Z = ϟa.Value2
s.W = ϟa.Value3
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _ = context, GetContext_43_result, ctx, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Push(value.F32(ϟa.Value2))
ϟb.Push(value.F32(ϟa.Value3))
ϟb.Call(funcInfoGlUniform4f)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform1fv{}) // interface compliance check
func (ϟa *GlUniform1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_44_result := context // Contextʳ
ctx := GetContext_44_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT
uniform.Value.F32 = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_44_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform1fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform2fv{}) // interface compliance check
func (ϟa *GlUniform2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_45_result := context // Contextʳ
ctx := GetContext_45_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(2))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC2
uniform.Value.Vec2f = func() Vec2f {
s := Vec2f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_45_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform2fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform3fv{}) // interface compliance check
func (ϟa *GlUniform3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_46_result := context // Contextʳ
ctx := GetContext_46_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(3))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC3
uniform.Value.Vec3f = func() Vec3f {
s := Vec3f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_46_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform3fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniform4fv{}) // interface compliance check
func (ϟa *GlUniform4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_47_result := context // Contextʳ
ctx := GetContext_47_result // Contextʳ
v := ϟa.Value.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(4))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_VEC4
uniform.Value.Vec4f = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(3), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_47_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlUniform4fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniformMatrix2fv{}) // interface compliance check
func (ϟa *GlUniformMatrix2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_48_result := context // Contextʳ
ctx := GetContext_48_result // Contextʳ
v := ϟa.Values.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(4))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_MAT2
uniform.Value.Mat2f = func() Mat2f {
s := Mat2f{}
s.Init()
s.Col0 = func() Vec2f {
s := Vec2f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col1 = func() Vec2f {
s := Vec2f{}
s.Init()
s.X = v.Index(uint64(3), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(4), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_48_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(value.Bool(ϟa.Transpose))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlUniformMatrix2fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniformMatrix3fv{}) // interface compliance check
func (ϟa *GlUniformMatrix3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_49_result := context // Contextʳ
ctx := GetContext_49_result // Contextʳ
v := ϟa.Values.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(9))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Type = ShaderUniformType_GL_FLOAT_MAT3
uniform.Value.Mat3f = func() Mat3f {
s := Mat3f{}
s.Init()
s.Col0 = func() Vec3f {
s := Vec3f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col1 = func() Vec3f {
s := Vec3f{}
s.Init()
s.X = v.Index(uint64(3), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(4), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(5), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col2 = func() Vec3f {
s := Vec3f{}
s.Init()
s.X = v.Index(uint64(6), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(7), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(8), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_49_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(value.Bool(ϟa.Transpose))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlUniformMatrix3fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlUniformMatrix4fv{}) // interface compliance check
func (ϟa *GlUniformMatrix4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_50_result := context // Contextʳ
ctx := GetContext_50_result // Contextʳ
v := ϟa.Values.Slice(uint64(int32(0)), uint64((ϟa.Count)*(int32(16))), ϟs) // F32ˢ
program := ctx.Instances.Programs.Get(ctx.BoundProgram) // Programʳ
uniform := program.Uniforms.Get(ϟa.Location) // Uniform
uniform.Value.Mat4f = func() Mat4f {
s := Mat4f{}
s.Init()
s.Col0 = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = v.Index(uint64(0), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(1), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(2), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(3), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col1 = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = v.Index(uint64(4), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(5), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(6), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(7), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col2 = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = v.Index(uint64(8), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(9), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(10), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(11), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
s.Col3 = func() Vec4f {
s := Vec4f{}
s.Init()
s.X = v.Index(uint64(12), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Y = v.Index(uint64(13), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.Z = v.Index(uint64(14), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
s.W = v.Index(uint64(15), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
return s
}()
return s
}()
program.Uniforms[ϟa.Location] = uniform
_, _, _, _, _, _ = context, GetContext_50_result, ctx, v, program, uniform
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Location.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(value.Bool(ϟa.Transpose))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlUniformMatrix4fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetUniformfv{}) // interface compliance check
func (ϟa *GlGetUniformfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlGetUniformfv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetUniformiv{}) // interface compliance check
func (ϟa *GlGetUniformiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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, ϟa.Location.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
}
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlGetUniformiv)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib1f{}) // interface compliance check
func (ϟa *GlVertexAttrib1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Call(funcInfoGlVertexAttrib1f)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib2f{}) // interface compliance check
func (ϟa *GlVertexAttrib2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Call(funcInfoGlVertexAttrib2f)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib3f{}) // interface compliance check
func (ϟa *GlVertexAttrib3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Push(value.F32(ϟa.Value2))
ϟb.Call(funcInfoGlVertexAttrib3f)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib4f{}) // interface compliance check
func (ϟa *GlVertexAttrib4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(value.F32(ϟa.Value0))
ϟb.Push(value.F32(ϟa.Value1))
ϟb.Push(value.F32(ϟa.Value2))
ϟb.Push(value.F32(ϟa.Value3))
ϟb.Call(funcInfoGlVertexAttrib4f)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib1fv{}) // interface compliance check
func (ϟa *GlVertexAttrib1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlVertexAttrib1fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib2fv{}) // interface compliance check
func (ϟa *GlVertexAttrib2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(2), ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlVertexAttrib2fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib3fv{}) // interface compliance check
func (ϟa *GlVertexAttrib3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(3), ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlVertexAttrib3fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlVertexAttrib4fv{}) // interface compliance check
func (ϟa *GlVertexAttrib4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Value.Slice(uint64(0), uint64(4), ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlVertexAttrib4fv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetShaderPrecisionFormat{}) // interface compliance check
func (ϟa *GlGetShaderPrecisionFormat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Range.Slice(uint64(0), uint64(2), ϟs).onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.Precision.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(ϟa.Precision.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.ShaderType))
ϟb.Push(value.U32(ϟa.PrecisionType))
ϟb.Push(ϟa.Range.value())
ϟb.Push(ϟa.Precision.value())
ϟb.Call(funcInfoGlGetShaderPrecisionFormat)
ϟp.exec()
}
var _ = replay.Replayer(&GlDepthMask{}) // interface compliance check
func (ϟa *GlDepthMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_51_result := context // Contextʳ
ctx := GetContext_51_result // Contextʳ
ctx.Rasterizing.DepthMask = ϟa.Enabled
_, _, _ = context, GetContext_51_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.Bool(ϟa.Enabled))
ϟb.Call(funcInfoGlDepthMask)
ϟp.exec()
}
var _ = replay.Replayer(&GlDepthFunc{}) // interface compliance check
func (ϟa *GlDepthFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_52_result := context // Contextʳ
ctx := GetContext_52_result // Contextʳ
ctx.Rasterizing.DepthTestFunction = ϟa.Function
_, _, _ = context, GetContext_52_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Function))
ϟb.Call(funcInfoGlDepthFunc)
ϟp.exec()
}
var _ = replay.Replayer(&GlDepthRangef{}) // interface compliance check
func (ϟa *GlDepthRangef) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_53_result := context // Contextʳ
ctx := GetContext_53_result // Contextʳ
ctx.Rasterizing.DepthNear = ϟa.Near
ctx.Rasterizing.DepthFar = ϟa.Far
_, _, _ = context, GetContext_53_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.Near))
ϟb.Push(value.F32(ϟa.Far))
ϟb.Call(funcInfoGlDepthRangef)
ϟp.exec()
}
var _ = replay.Replayer(&GlColorMask{}) // interface compliance check
func (ϟa *GlColorMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_54_result := context // Contextʳ
ctx := GetContext_54_result // Contextʳ
ctx.Rasterizing.ColorMaskRed = ϟa.Red
ctx.Rasterizing.ColorMaskGreen = ϟa.Green
ctx.Rasterizing.ColorMaskBlue = ϟa.Blue
ctx.Rasterizing.ColorMaskAlpha = ϟa.Alpha
_, _, _ = context, GetContext_54_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.Bool(ϟa.Red))
ϟb.Push(value.Bool(ϟa.Green))
ϟb.Push(value.Bool(ϟa.Blue))
ϟb.Push(value.Bool(ϟa.Alpha))
ϟb.Call(funcInfoGlColorMask)
ϟp.exec()
}
var _ = replay.Replayer(&GlStencilMask{}) // interface compliance check
func (ϟa *GlStencilMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_55_result := context // Contextʳ
ctx := GetContext_55_result // Contextʳ
ctx.Rasterizing.StencilMask[FaceMode_GL_FRONT] = ϟa.Mask
ctx.Rasterizing.StencilMask[FaceMode_GL_BACK] = ϟa.Mask
_, _, _ = context, GetContext_55_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Call(funcInfoGlStencilMask)
ϟp.exec()
}
var _ = replay.Replayer(&GlStencilMaskSeparate{}) // interface compliance check
func (ϟa *GlStencilMaskSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_56_result := context // Contextʳ
ctx := GetContext_56_result // Contextʳ
switch ϟa.Face {
case FaceMode_GL_FRONT:
ctx.Rasterizing.StencilMask[FaceMode_GL_FRONT] = ϟa.Mask
case FaceMode_GL_BACK:
ctx.Rasterizing.StencilMask[FaceMode_GL_BACK] = ϟa.Mask
case FaceMode_GL_FRONT_AND_BACK:
ctx.Rasterizing.StencilMask[FaceMode_GL_FRONT] = ϟa.Mask
ctx.Rasterizing.StencilMask[FaceMode_GL_BACK] = ϟa.Mask
default:
// TODO: better unmatched handling
v := ϟa.Face
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _ = context, GetContext_56_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Call(funcInfoGlStencilMaskSeparate)
ϟp.exec()
}
var _ = replay.Replayer(&GlStencilFuncSeparate{}) // interface compliance check
func (ϟa *GlStencilFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Face))
ϟb.Push(value.U32(ϟa.Function))
ϟb.Push(value.S32(ϟa.ReferenceValue))
ϟb.Push(value.S32(ϟa.Mask))
ϟb.Call(funcInfoGlStencilFuncSeparate)
ϟp.exec()
}
var _ = replay.Replayer(&GlStencilOpSeparate{}) // interface compliance check
func (ϟa *GlStencilOpSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟ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)
ϟp.exec()
}
var _ = replay.Replayer(&GlFrontFace{}) // interface compliance check
func (ϟa *GlFrontFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_57_result := context // Contextʳ
ctx := GetContext_57_result // Contextʳ
ctx.Rasterizing.FrontFace = ϟa.Orientation
_, _, _ = context, GetContext_57_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Orientation))
ϟb.Call(funcInfoGlFrontFace)
ϟp.exec()
}
var _ = replay.Replayer(&GlViewport{}) // interface compliance check
func (ϟa *GlViewport) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_58_result := context // Contextʳ
ctx := GetContext_58_result // Contextʳ
ctx.Rasterizing.Viewport = func() Rect {
s := Rect{}
s.Init()
s.X = ϟa.X
s.Y = ϟa.Y
s.Width = ϟa.Width
s.Height = ϟa.Height
return s
}()
_, _, _ = context, GetContext_58_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlViewport)
ϟp.exec()
}
var _ = replay.Replayer(&GlScissor{}) // interface compliance check
func (ϟa *GlScissor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_59_result := context // Contextʳ
ctx := GetContext_59_result // Contextʳ
ctx.Rasterizing.Scissor = func() Rect {
s := Rect{}
s.Init()
s.X = ϟa.X
s.Y = ϟa.Y
s.Width = ϟa.Width
s.Height = ϟa.Height
return s
}()
_, _, _ = context, GetContext_59_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlScissor)
ϟp.exec()
}
var _ = replay.Replayer(&GlActiveTexture{}) // interface compliance check
func (ϟa *GlActiveTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_60_result := context // Contextʳ
ctx := GetContext_60_result // Contextʳ
ctx.ActiveTextureUnit = ϟa.Unit
if !(ctx.TextureUnits.Contains(ϟa.Unit)) {
ctx.TextureUnits[ϟa.Unit] = ctx.TextureUnits.Get(ϟa.Unit)
}
_, _, _ = context, GetContext_60_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Unit))
ϟb.Call(funcInfoGlActiveTexture)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenTextures{}) // interface compliance check
func (ϟa *GlGenTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
t := ϟa.Textures.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // TextureIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_61_result := context // Contextʳ
ctx := GetContext_61_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
id := TextureId(ϟa.Textures.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // TextureId
ctx.Instances.Textures[id] = func() *Texture {
s := &Texture{}
s.Init()
return s
}()
t.Index(uint64(i), ϟs).replayWrite(id, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = id
}
_, _, _, _ = t, context, GetContext_61_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Textures.value())
ϟb.Call(funcInfoGlGenTextures)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteTextures{}) // interface compliance check
func (ϟa *GlDeleteTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
t := ϟa.Textures.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // TextureIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_62_result := context // Contextʳ
ctx := GetContext_62_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
ctx.Instances.Textures[t.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)] = (*Texture)(nil)
}
_, _, _, _ = t, context, GetContext_62_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Textures.value())
ϟb.Call(funcInfoGlDeleteTextures)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsTexture{}) // interface compliance check
func (ϟa *GlIsTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_63_result := context // Contextʳ
ctx := GetContext_63_result // Contextʳ
ϟa.Result = ctx.Instances.Textures.Contains(ϟa.Texture)
_, _, _ = context, GetContext_63_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsTexture)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindTexture{}) // interface compliance check
func (ϟa *GlBindTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_64_result := context // Contextʳ
ctx := GetContext_64_result // Contextʳ
if !(ctx.Instances.Textures.Contains(ϟa.Texture)) {
ctx.Instances.Textures[ϟa.Texture] = func() *Texture {
s := &Texture{}
s.Init()
return s
}()
}
ctx.TextureUnits.Get(ctx.ActiveTextureUnit)[ϟa.Target] = ϟa.Texture
_, _, _ = context, GetContext_64_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Texture.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Texture.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Texture.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindTexture)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexImage2D{}) // interface compliance check
func (ϟa *GlTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_65_result := context // Contextʳ
ctx := GetContext_65_result // Contextʳ
switch ϟa.Target {
case TextureImageTarget_GL_TEXTURE_2D:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_2D) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = externs{ϟs, ϟd, ϟl}.imageSize(uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if (ϟa.Data) != (TexturePointer(Voidᵖ{})) {
if (ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
} else {
l.Data = MakeU8ˢ(uint64(l.Size), ϟs)
}
t.Texture2D[ϟa.Level] = l
t.Kind = TextureKind_TEXTURE2D
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _ = id, t, l
case TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_CUBE_MAP) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = externs{ϟs, ϟd, ϟl}.imageSize(uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if (ϟa.Data) != (TexturePointer(Voidᵖ{})) {
if (ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
} else {
l.Data = MakeU8ˢ(uint64(l.Size), ϟs)
}
cube := t.Cubemap.Get(ϟa.Level) // CubemapLevel
cube.Faces[CubeMapImageTarget(ϟa.Target)] = l
t.Cubemap[ϟa.Level] = cube
t.Kind = TextureKind_CUBEMAP
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _, _ = id, t, l, cube
default:
// TODO: better unmatched handling
v := ϟa.Target
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _ = context, GetContext_65_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.U32(ϟa.InternalFormat))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.S32(ϟa.Border))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlTexSubImage2D{}) // interface compliance check
func (ϟa *GlTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_66_result := context // Contextʳ
ctx := GetContext_66_result // Contextʳ
switch ϟa.Target {
case TextureImageTarget_GL_TEXTURE_2D:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_2D) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = externs{ϟs, ϟd, ϟl}.imageSize(uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if ((ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
t.Texture2D[ϟa.Level] = l
t.Kind = TextureKind_TEXTURE2D
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _ = id, t, l
case TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_CUBE_MAP) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = externs{ϟs, ϟd, ϟl}.imageSize(uint32(ϟa.Width), uint32(ϟa.Height), ϟa.Format, ϟa.Type)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if ((ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
cube := t.Cubemap.Get(ϟa.Level) // CubemapLevel
cube.Faces[CubeMapImageTarget(ϟa.Target)] = l
t.Cubemap[ϟa.Level] = cube
t.Kind = TextureKind_CUBEMAP
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _, _ = id, t, l, cube
default:
// TODO: better unmatched handling
v := ϟa.Target
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _ = context, GetContext_66_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.S32(ϟa.Xoffset))
ϟb.Push(value.S32(ϟa.Yoffset))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlTexSubImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlCopyTexImage2D{}) // interface compliance check
func (ϟa *GlCopyTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.S32(ϟa.Border))
ϟb.Call(funcInfoGlCopyTexImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlCopyTexSubImage2D{}) // interface compliance check
func (ϟa *GlCopyTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.S32(ϟa.Xoffset))
ϟb.Push(value.S32(ϟa.Yoffset))
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlCopyTexSubImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlCompressedTexImage2D{}) // interface compliance check
func (ϟa *GlCompressedTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_67_result := context // Contextʳ
ctx := GetContext_67_result // Contextʳ
switch ϟa.Target {
case TextureImageTarget_GL_TEXTURE_2D:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_2D) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = uint32(ϟa.ImageSize)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if ((ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
t.Texture2D[ϟa.Level] = l
t.Kind = TextureKind_TEXTURE2D
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _ = id, t, l
case TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TextureImageTarget_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
id := ctx.TextureUnits.Get(ctx.ActiveTextureUnit).Get(TextureTarget_GL_TEXTURE_CUBE_MAP) // TextureId
t := ctx.Instances.Textures.Get(id) // Textureʳ
l := func() Image {
s := Image{}
s.Init()
s.Width = ϟa.Width
s.Height = ϟa.Height
s.Size = uint32(ϟa.ImageSize)
s.Format = ImageTexelFormat(ϟa.Format)
return s
}() // Image
if ((ctx.BoundBuffers.Get(BufferTarget_GL_PIXEL_UNPACK_BUFFER)) == (BufferId(uint32(0)))) && ((ϟa.Data) != (TexturePointer(Voidᵖ{}))) {
l.Data = U8ᵖ(ϟa.Data).Slice(uint64(uint32(0)), uint64(l.Size), ϟs).Clone(ϟs)
}
cube := t.Cubemap.Get(ϟa.Level) // CubemapLevel
cube.Faces[CubeMapImageTarget(ϟa.Target)] = l
t.Cubemap[ϟa.Level] = cube
t.Kind = TextureKind_CUBEMAP
t.Format = ImageTexelFormat(ϟa.Format)
_, _, _, _ = id, t, l, cube
default:
// TODO: better unmatched handling
v := ϟa.Target
fmt.Printf("Error: Missing switch case handler for value %T %v", v, v)
}
_, _, _ = context, GetContext_67_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.S32(ϟa.Border))
ϟb.Push(value.S32(ϟa.ImageSize))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlCompressedTexSubImage2D{}) // interface compliance check
func (ϟa *GlCompressedTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Level))
ϟb.Push(value.S32(ϟa.Xoffset))
ϟb.Push(value.S32(ϟa.Yoffset))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.ImageSize))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Call(funcInfoGlCompressedTexSubImage2D)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenerateMipmap{}) // interface compliance check
func (ϟa *GlGenerateMipmap) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlGenerateMipmap)
ϟp.exec()
}
var _ = replay.Replayer(&GlReadPixels{}) // interface compliance check
func (ϟa *GlReadPixels) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Data.Slice(uint64(uint32(0)), uint64(externs{ϟs, ϟd, ϟl}.imageSize(uint32(ϟa.Width), uint32(ϟa.Height), TexelFormat(ϟa.Format), ϟa.Type)), ϟs).onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.X))
ϟb.Push(value.S32(ϟa.Y))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.U32(ϟa.Type))
ϟb.Push(ϟa.Data.value())
ϟb.Call(funcInfoGlReadPixels)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenFramebuffers{}) // interface compliance check
func (ϟa *GlGenFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
f := ϟa.Framebuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // FramebufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_68_result := context // Contextʳ
ctx := GetContext_68_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
id := FramebufferId(ϟa.Framebuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // FramebufferId
ctx.Instances.Framebuffers[id] = func() *Framebuffer {
s := &Framebuffer{}
s.Init()
return s
}()
f.Index(uint64(i), ϟs).replayWrite(id, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = id
}
_, _, _, _ = f, context, GetContext_68_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Framebuffers.value())
ϟb.Call(funcInfoGlGenFramebuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindFramebuffer{}) // interface compliance check
func (ϟa *GlBindFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_69_result := context // Contextʳ
ctx := GetContext_69_result // Contextʳ
if !(ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer)) {
ctx.Instances.Framebuffers[ϟa.Framebuffer] = func() *Framebuffer {
s := &Framebuffer{}
s.Init()
return s
}()
}
if (ϟa.Target) == (FramebufferTarget_GL_FRAMEBUFFER) {
ctx.BoundFramebuffers[FramebufferTarget_GL_READ_FRAMEBUFFER] = ϟa.Framebuffer
ctx.BoundFramebuffers[FramebufferTarget_GL_DRAW_FRAMEBUFFER] = ϟa.Framebuffer
} else {
ctx.BoundFramebuffers[ϟa.Target] = ϟa.Framebuffer
}
_, _, _ = context, GetContext_69_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Framebuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindFramebuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlCheckFramebufferStatus{}) // interface compliance check
func (ϟa *GlCheckFramebufferStatus) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Result = ϟa.Result
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Call(funcInfoGlCheckFramebufferStatus)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteFramebuffers{}) // interface compliance check
func (ϟa *GlDeleteFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
f := ϟa.Framebuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // FramebufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_70_result := context // Contextʳ
ctx := GetContext_70_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
ctx.Instances.Framebuffers[f.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)] = (*Framebuffer)(nil)
}
_, _, _, _ = f, context, GetContext_70_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Framebuffers.value())
ϟb.Call(funcInfoGlDeleteFramebuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsFramebuffer{}) // interface compliance check
func (ϟa *GlIsFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_71_result := context // Contextʳ
ctx := GetContext_71_result // Contextʳ
ϟa.Result = ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer)
_, _, _ = context, GetContext_71_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Framebuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Framebuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsFramebuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenRenderbuffers{}) // interface compliance check
func (ϟa *GlGenRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
r := ϟa.Renderbuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // RenderbufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_72_result := context // Contextʳ
ctx := GetContext_72_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
id := RenderbufferId(ϟa.Renderbuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // RenderbufferId
ctx.Instances.Renderbuffers[id] = func() *Renderbuffer {
s := &Renderbuffer{}
s.Init()
return s
}()
r.Index(uint64(i), ϟs).replayWrite(id, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = id
}
_, _, _, _ = r, context, GetContext_72_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Renderbuffers.value())
ϟb.Call(funcInfoGlGenRenderbuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindRenderbuffer{}) // interface compliance check
func (ϟa *GlBindRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_73_result := context // Contextʳ
ctx := GetContext_73_result // Contextʳ
if !(ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer)) {
ctx.Instances.Renderbuffers[ϟa.Renderbuffer] = func() *Renderbuffer {
s := &Renderbuffer{}
s.Init()
return s
}()
}
ctx.BoundRenderbuffers[ϟa.Target] = ϟa.Renderbuffer
_, _, _ = context, GetContext_73_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Renderbuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindRenderbuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlRenderbufferStorage{}) // interface compliance check
func (ϟa *GlRenderbufferStorage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_74_result := context // Contextʳ
ctx := GetContext_74_result // Contextʳ
id := ctx.BoundRenderbuffers.Get(ϟa.Target) // RenderbufferId
rb := ctx.Instances.Renderbuffers.Get(id) // Renderbufferʳ
rb.Format = ϟa.Format
rb.Width = ϟa.Width
rb.Height = ϟa.Height
_, _, _, _, _ = context, GetContext_74_result, ctx, id, rb
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Format))
ϟb.Push(value.S32(ϟa.Width))
ϟb.Push(value.S32(ϟa.Height))
ϟb.Call(funcInfoGlRenderbufferStorage)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteRenderbuffers{}) // interface compliance check
func (ϟa *GlDeleteRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
r := ϟa.Renderbuffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // RenderbufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_75_result := context // Contextʳ
ctx := GetContext_75_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
ctx.Instances.Renderbuffers[r.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)] = (*Renderbuffer)(nil)
}
_, _, _, _ = r, context, GetContext_75_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Renderbuffers.value())
ϟb.Call(funcInfoGlDeleteRenderbuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsRenderbuffer{}) // interface compliance check
func (ϟa *GlIsRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_76_result := context // Contextʳ
ctx := GetContext_76_result // Contextʳ
ϟa.Result = ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer)
_, _, _ = context, GetContext_76_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Renderbuffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Renderbuffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsRenderbuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetRenderbufferParameteriv{}) // interface compliance check
func (ϟa *GlGetRenderbufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_77_result := context // Contextʳ
ctx := GetContext_77_result // Contextʳ
id := ctx.BoundRenderbuffers.Get(ϟa.Target) // RenderbufferId
rb := ctx.Instances.Renderbuffers.Get(id) // Renderbufferʳ
ϟa.Values.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(func() (result int32) {
switch ϟa.Parameter {
case RenderbufferParameter_GL_RENDERBUFFER_WIDTH:
return rb.Width
case RenderbufferParameter_GL_RENDERBUFFER_HEIGHT:
return rb.Height
case RenderbufferParameter_GL_RENDERBUFFER_INTERNAL_FORMAT:
return int32(rb.Format)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _ = context, GetContext_77_result, ctx, id, rb
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Values.value())
ϟb.Call(funcInfoGlGetRenderbufferParameteriv)
ϟp.exec()
}
var _ = replay.Replayer(&GlGenBuffers{}) // interface compliance check
func (ϟa *GlGenBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
b := ϟa.Buffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // BufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_78_result := context // Contextʳ
ctx := GetContext_78_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
id := BufferId(ϟa.Buffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs).Index(uint64(i), ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb)) // BufferId
ctx.Instances.Buffers[id] = func() *Buffer {
s := &Buffer{}
s.Init()
return s
}()
b.Index(uint64(i), ϟs).replayWrite(id, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_ = id
}
_, _, _, _ = b, context, GetContext_78_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Buffers.value())
ϟb.Call(funcInfoGlGenBuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlBindBuffer{}) // interface compliance check
func (ϟa *GlBindBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_79_result := context // Contextʳ
ctx := GetContext_79_result // Contextʳ
if !(ctx.Instances.Buffers.Contains(ϟa.Buffer)) {
ctx.Instances.Buffers[ϟa.Buffer] = func() *Buffer {
s := &Buffer{}
s.Init()
return s
}()
}
ctx.BoundBuffers[ϟa.Target] = ϟa.Buffer
_, _, _ = context, GetContext_79_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlBindBuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlBufferData{}) // interface compliance check
func (ϟa *GlBufferData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_80_result := context // Contextʳ
ctx := GetContext_80_result // Contextʳ
id := ctx.BoundBuffers.Get(ϟa.Target) // BufferId
b := ctx.Instances.Buffers.Get(id) // Bufferʳ
b.Data = func() (result U8ˢ) {
switch (ϟa.Data) != (BufferDataPointer(Voidᵖ{})) {
case true:
return U8ᵖ(ϟa.Data).Slice(uint64(int32(0)), uint64(ϟa.Size), ϟs).Clone(ϟs)
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
_, _, _, _, _ = context, GetContext_80_result, ctx, id, b
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Size))
ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs))
ϟb.Push(value.U32(ϟa.Usage))
ϟb.Call(funcInfoGlBufferData)
ϟp.exec()
}
var _ = replay.Replayer(&GlBufferSubData{}) // interface compliance check
func (ϟa *GlBufferSubData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.Data.Slice(uint64(int32(0)), uint64(ϟa.Size), ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb)
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.S32(ϟa.Offset))
ϟb.Push(value.S32(ϟa.Size))
ϟb.Push(ϟa.Data.value())
ϟb.Call(funcInfoGlBufferSubData)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteBuffers{}) // interface compliance check
func (ϟa *GlDeleteBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
b := ϟa.Buffers.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // BufferIdˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_81_result := context // Contextʳ
ctx := GetContext_81_result // Contextʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
ctx.Instances.Buffers[b.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)] = (*Buffer)(nil)
}
_, _, _, _ = b, context, GetContext_81_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Buffers.value())
ϟb.Call(funcInfoGlDeleteBuffers)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsBuffer{}) // interface compliance check
func (ϟa *GlIsBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_82_result := context // Contextʳ
ctx := GetContext_82_result // Contextʳ
ϟa.Result = ctx.Instances.Buffers.Contains(ϟa.Buffer)
_, _, _ = context, GetContext_82_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Buffer.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Buffer.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Buffer.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsBuffer)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetBufferParameteriv{}) // interface compliance check
func (ϟa *GlGetBufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_83_result := context // Contextʳ
ctx := GetContext_83_result // Contextʳ
id := ctx.BoundBuffers.Get(ϟa.Target) // BufferId
b := ctx.Instances.Buffers.Get(id) // Bufferʳ
ϟa.Value.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(func() (result int32) {
switch ϟa.Parameter {
case BufferParameter_GL_BUFFER_SIZE:
return b.Size
case BufferParameter_GL_BUFFER_USAGE:
return int32(b.Usage)
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.Parameter, ϟa))
return result
}
}(), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _ = context, GetContext_83_result, ctx, id, b
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Parameter))
ϟb.Push(ϟa.Value.value())
ϟb.Call(funcInfoGlGetBufferParameteriv)
ϟp.exec()
}
var _ = replay.Replayer(&GlCreateShader{}) // interface compliance check
func (ϟa *GlCreateShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_84_result := context // Contextʳ
ctx := GetContext_84_result // Contextʳ
id := ShaderId(ϟa.Result) // ShaderId
ctx.Instances.Shaders[id] = func() *Shader {
s := &Shader{}
s.Init()
return s
}()
s := ctx.Instances.Shaders.Get(id) // Shaderʳ
s.Type = ϟa.Type
ϟa.Result = id
_, _, _, _, _ = context, GetContext_84_result, ctx, id, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Type))
ϟb.Call(funcInfoGlCreateShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteShader{}) // interface compliance check
func (ϟa *GlDeleteShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_85_result := context // Contextʳ
ctx := GetContext_85_result // Contextʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
s.Deletable = true
ctx.Instances.Shaders[ϟa.Shader] = (*Shader)(nil)
_, _, _, _ = context, GetContext_85_result, ctx, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlShaderSource{}) // interface compliance check
func (ϟa *GlShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
sources := ϟa.Source.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // Charᵖˢ
lengths := ϟa.Length.Slice(uint64(int32(0)), uint64(ϟa.Count), ϟs) // S32ˢ
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_86_result := context // Contextʳ
ctx := GetContext_86_result // Contextʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
for i := int32(int32(0)); i < ϟa.Count; i++ {
l := func() (result uint32) {
switch ((ϟa.Length) == (S32ᵖ{})) || ((lengths.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)) < (int32(0))) {
case true:
return externs{ϟs, ϟd, ϟl}.strlen(sources.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb))
case false:
return uint32(lengths.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb))
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ((ϟa.Length) == (S32ᵖ{})) || ((lengths.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb)) < (int32(0))), ϟa))
return result
}
}() // u32
s.Source += string(sources.Index(uint64(i), ϟs).replayRead(ϟa, ϟs, ϟd, ϟl, ϟb).Slice(uint64(uint32(0)), uint64(l), ϟs).Read(ϟs, ϟd, ϟl))
_ = l
}
_, _, _, _, _, _ = sources, lengths, context, GetContext_86_result, ctx, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Source.value())
ϟb.Push(ϟa.Length.value())
ϟb.Call(funcInfoGlShaderSource)
ϟp.exec()
}
var _ = replay.Replayer(&GlShaderBinary{}) // interface compliance check
func (ϟa *GlShaderBinary) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
for i := int32(int32(0)); i < ϟa.Count; i++ {
}
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Count))
ϟb.Push(ϟa.Shaders.value())
ϟb.Push(value.U32(ϟa.BinaryFormat))
ϟb.Push(ϟa.Binary.value())
ϟb.Push(value.S32(ϟa.BinarySize))
ϟb.Call(funcInfoGlShaderBinary)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetShaderInfoLog{}) // interface compliance check
func (ϟa *GlGetShaderInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_87_result := context // Contextʳ
ctx := GetContext_87_result // Contextʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
min_88_a := ϟa.BufferLength // s32
min_88_b := int32(externs{ϟs, ϟd, ϟl}.strlen(s.InfoLog)) // s32
min_88_result := func() (result int32) {
switch (min_88_a) < (min_88_b) {
case true:
return min_88_a
case false:
return min_88_b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (min_88_a) < (min_88_b), ϟa))
return result
}
}() // s32
l := min_88_result // s32
ϟa.Info.Slice(uint64(int32(0)), uint64(l), ϟs).replayCopy(s.InfoLog.Slice(uint64(int32(0)), uint64(l), ϟs), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.StringLengthWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(l, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _, _, _, _ = context, GetContext_87_result, ctx, s, min_88_a, min_88_b, min_88_result, l
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.BufferLength))
ϟb.Push(ϟa.StringLengthWritten.value())
ϟb.Push(ϟa.Info.value())
ϟb.Call(funcInfoGlGetShaderInfoLog)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetShaderSource{}) // interface compliance check
func (ϟa *GlGetShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_89_result := context // Contextʳ
ctx := GetContext_89_result // Contextʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
min_90_a := ϟa.BufferLength // s32
min_90_b := int32(externs{ϟs, ϟd, ϟl}.strlen(s.Source)) // s32
min_90_result := func() (result int32) {
switch (min_90_a) < (min_90_b) {
case true:
return min_90_a
case false:
return min_90_b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (min_90_a) < (min_90_b), ϟa))
return result
}
}() // s32
l := min_90_result // s32
ϟa.Source.Slice(uint64(int32(0)), uint64(l), ϟs).replayCopy(MakeCharˢFromString(s.Source, ϟs).Slice(uint64(int32(0)), uint64(l), ϟs), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.StringLengthWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(l, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _, _, _, _ = context, GetContext_89_result, ctx, s, min_90_a, min_90_b, min_90_result, l
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.BufferLength))
ϟb.Push(ϟa.StringLengthWritten.value())
ϟb.Push(ϟa.Source.value())
ϟb.Call(funcInfoGlGetShaderSource)
ϟp.exec()
}
var _ = replay.Replayer(&GlReleaseShaderCompiler{}) // interface compliance check
func (ϟa *GlReleaseShaderCompiler) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoGlReleaseShaderCompiler)
ϟp.exec()
}
var _ = replay.Replayer(&GlCompileShader{}) // interface compliance check
func (ϟa *GlCompileShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlCompileShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsShader{}) // interface compliance check
func (ϟa *GlIsShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_91_result := context // Contextʳ
ctx := GetContext_91_result // Contextʳ
ϟa.Result = ctx.Instances.Shaders.Contains(ϟa.Shader)
_, _, _ = context, GetContext_91_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Shader.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlCreateProgram{}) // interface compliance check
func (ϟa *GlCreateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_92_result := context // Contextʳ
ctx := GetContext_92_result // Contextʳ
id := ProgramId(ϟa.Result) // ProgramId
ctx.Instances.Programs[id] = func() *Program {
s := &Program{}
s.Init()
return s
}()
ϟa.Result = id
_, _, _, _ = context, GetContext_92_result, ctx, id
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Call(funcInfoGlCreateProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlDeleteProgram{}) // interface compliance check
func (ϟa *GlDeleteProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_93_result := context // Contextʳ
ctx := GetContext_93_result // Contextʳ
ctx.Instances.Programs[ϟa.Program] = (*Program)(nil)
_, _, _ = context, GetContext_93_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDeleteProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlAttachShader{}) // interface compliance check
func (ϟa *GlAttachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_94_result := context // Contextʳ
ctx := GetContext_94_result // Contextʳ
p := ctx.Instances.Programs.Get(ϟa.Program) // Programʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
p.Shaders[s.Type] = ϟa.Shader
_, _, _, _, _ = context, GetContext_94_result, ctx, p, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlAttachShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlDetachShader{}) // interface compliance check
func (ϟa *GlDetachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_95_result := context // Contextʳ
ctx := GetContext_95_result // Contextʳ
p := ctx.Instances.Programs.Get(ϟa.Program) // Programʳ
s := ctx.Instances.Shaders.Get(ϟa.Shader) // Shaderʳ
p.Shaders[s.Type] = ShaderId(uint32(0))
_, _, _, _, _ = context, GetContext_95_result, ctx, p, s
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟ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, ϟa.Shader.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Shader.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlDetachShader)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetAttachedShaders{}) // interface compliance check
func (ϟa *GlGetAttachedShaders) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_96_result := context // Contextʳ
ctx := GetContext_96_result // Contextʳ
p := ctx.Instances.Programs.Get(ϟa.Program) // Programʳ
min_97_a := ϟa.BufferLength // s32
min_97_b := int32(len(p.Shaders)) // s32
min_97_result := func() (result int32) {
switch (min_97_a) < (min_97_b) {
case true:
return min_97_a
case false:
return min_97_b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (min_97_a) < (min_97_b), ϟa))
return result
}
}() // s32
l := min_97_result // s32
ϟa.ShadersLengthWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(l, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _, _, _, _ = context, GetContext_96_result, ctx, p, min_97_a, min_97_b, min_97_result, l
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.BufferLength))
ϟb.Push(ϟa.ShadersLengthWritten.value())
ϟb.Push(ϟa.Shaders.value())
ϟb.Call(funcInfoGlGetAttachedShaders)
ϟp.exec()
}
var _ = replay.Replayer(&GlLinkProgram{}) // interface compliance check
func (ϟa *GlLinkProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlLinkProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlGetProgramInfoLog{}) // interface compliance check
func (ϟa *GlGetProgramInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_98_result := context // Contextʳ
ctx := GetContext_98_result // Contextʳ
p := ctx.Instances.Programs.Get(ϟa.Program) // Programʳ
min_99_a := ϟa.BufferLength // s32
min_99_b := int32(externs{ϟs, ϟd, ϟl}.strlen(p.InfoLog)) // s32
min_99_result := func() (result int32) {
switch (min_99_a) < (min_99_b) {
case true:
return min_99_a
case false:
return min_99_b
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", (min_99_a) < (min_99_b), ϟa))
return result
}
}() // s32
l := min_99_result // s32
ϟa.Info.Slice(uint64(int32(0)), uint64(l), ϟs).replayCopy(p.InfoLog.Slice(uint64(int32(0)), uint64(l), ϟs), ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
ϟa.StringLengthWritten.Slice(uint64(0), uint64(1), ϟs).Index(uint64(0), ϟs).replayWrite(l, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp)
_, _, _, _, _, _, _, _ = context, GetContext_98_result, ctx, p, min_99_a, min_99_b, min_99_result, l
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Push(value.S32(ϟa.BufferLength))
ϟb.Push(ϟa.StringLengthWritten.value())
ϟb.Push(ϟa.Info.value())
ϟb.Call(funcInfoGlGetProgramInfoLog)
ϟp.exec()
}
var _ = replay.Replayer(&GlUseProgram{}) // interface compliance check
func (ϟa *GlUseProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_100_result := context // Contextʳ
ctx := GetContext_100_result // Contextʳ
ctx.BoundProgram = ϟa.Program
_, _, _ = context, GetContext_100_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlUseProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlIsProgram{}) // interface compliance check
func (ϟa *GlIsProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_101_result := context // Contextʳ
ctx := GetContext_101_result // Contextʳ
ϟa.Result = ctx.Instances.Programs.Contains(ϟa.Program)
_, _, _ = context, GetContext_101_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlIsProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlValidateProgram{}) // interface compliance check
func (ϟa *GlValidateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
if key, remap := ϟa.Program.remap(ϟa, ϟs); remap {
loadRemap(ϟb, key, ϟa.Program.value(ϟb, ϟa, ϟs))
} else {
ϟb.Push(ϟa.Program.value(ϟb, ϟa, ϟs))
}
ϟb.Call(funcInfoGlValidateProgram)
ϟp.exec()
}
var _ = replay.Replayer(&GlClearColor{}) // interface compliance check
func (ϟa *GlClearColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_102_result := context // Contextʳ
ctx := GetContext_102_result // Contextʳ
ctx.Clearing.ClearColor = func() Color {
s := Color{}
s.Init()
s.Red = ϟa.R
s.Green = ϟa.G
s.Blue = ϟa.B
s.Alpha = ϟa.A
return s
}()
_, _, _ = context, GetContext_102_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.R))
ϟb.Push(value.F32(ϟa.G))
ϟb.Push(value.F32(ϟa.B))
ϟb.Push(value.F32(ϟa.A))
ϟb.Call(funcInfoGlClearColor)
ϟp.exec()
}
var _ = replay.Replayer(&GlClearDepthf{}) // interface compliance check
func (ϟa *GlClearDepthf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_103_result := context // Contextʳ
ctx := GetContext_103_result // Contextʳ
ctx.Clearing.ClearDepth = ϟa.Depth
_, _, _ = context, GetContext_103_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.Depth))
ϟb.Call(funcInfoGlClearDepthf)
ϟp.exec()
}
var _ = replay.Replayer(&GlClearStencil{}) // interface compliance check
func (ϟa *GlClearStencil) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_104_result := context // Contextʳ
ctx := GetContext_104_result // Contextʳ
ctx.Clearing.ClearStencil = ϟa.Stencil
_, _, _ = context, GetContext_104_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.S32(ϟa.Stencil))
ϟb.Call(funcInfoGlClearStencil)
ϟp.exec()
}
var _ = replay.Replayer(&GlClear{}) // interface compliance check
func (ϟa *GlClear) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
if (ClearMask_GL_COLOR_BUFFER_BIT)&(ϟa.Mask) != 0 {
}
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Mask))
ϟb.Call(funcInfoGlClear)
ϟp.exec()
}
var _ = replay.Replayer(&GlCullFace{}) // interface compliance check
func (ϟa *GlCullFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_105_result := context // Contextʳ
ctx := GetContext_105_result // Contextʳ
ctx.Rasterizing.CullFace = ϟa.Mode
_, _, _ = context, GetContext_105_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlCullFace)
ϟp.exec()
}
var _ = replay.Replayer(&GlPolygonOffset{}) // interface compliance check
func (ϟa *GlPolygonOffset) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_106_result := context // Contextʳ
ctx := GetContext_106_result // Contextʳ
ctx.Rasterizing.PolygonOffsetUnits = ϟa.Units
ctx.Rasterizing.PolygonOffsetFactor = ϟa.ScaleFactor
_, _, _ = context, GetContext_106_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.ScaleFactor))
ϟb.Push(value.F32(ϟa.Units))
ϟb.Call(funcInfoGlPolygonOffset)
ϟp.exec()
}
var _ = replay.Replayer(&GlLineWidth{}) // interface compliance check
func (ϟa *GlLineWidth) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_107_result := context // Contextʳ
ctx := GetContext_107_result // Contextʳ
ctx.Rasterizing.LineWidth = ϟa.Width
_, _, _ = context, GetContext_107_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.Width))
ϟb.Call(funcInfoGlLineWidth)
ϟp.exec()
}
var _ = replay.Replayer(&GlSampleCoverage{}) // interface compliance check
func (ϟa *GlSampleCoverage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_108_result := context // Contextʳ
ctx := GetContext_108_result // Contextʳ
ctx.Rasterizing.SampleCoverageValue = ϟa.Value
ctx.Rasterizing.SampleCoverageInvert = ϟa.Invert
_, _, _ = context, GetContext_108_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.F32(ϟa.Value))
ϟb.Push(value.Bool(ϟa.Invert))
ϟb.Call(funcInfoGlSampleCoverage)
ϟp.exec()
}
var _ = replay.Replayer(&GlHint{}) // interface compliance check
func (ϟa *GlHint) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_109_result := context // Contextʳ
ctx := GetContext_109_result // Contextʳ
ctx.GenerateMipmapHint = ϟa.Mode
_, _, _ = context, GetContext_109_result, ctx
ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool])
ϟb.Push(value.U32(ϟa.Target))
ϟb.Push(value.U32(ϟa.Mode))
ϟb.Call(funcInfoGlHint)
ϟp.exec()
}
var _ = replay.Replayer(&GlFramebufferRenderbuffer{}) // interface compliance check
func (ϟa *GlFramebufferRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {
ϟc := getState(ϟs)
ϟp := &postCall{}
_ = ϟc
ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool])
context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ
GetContext_110_result := context // Contextʳ
ctx := GetContext_110_result // Contextʳ
target := func() (result FramebufferTarget) {
switch ϟa.FramebufferTarget {
case FramebufferTarget_GL_FRAMEBUFFER:
return FramebufferTarget_GL_DRAW_FRAMEBUFFER
case FramebufferTarget_GL_DRAW_FRAMEBUFFER:
return FramebufferTarget_GL_DRAW_FRAMEBUFFER
case FramebufferTarget_GL_READ_FRAMEBUFFER:
return FramebufferTarget_GL_READ_FRAMEBUFFER
default:
// TODO: better unmatched handling
panic(fmt.Errorf("Unmatched switch(%v) in atom %T", ϟa.FramebufferTarget, ϟa))
return result
}