diff options
40 files changed, 24126 insertions, 5588 deletions
diff --git a/api/apic/commands/README.md b/api/apic/commands/README.md index b02cbac15..b426d38bc 100644 --- a/api/apic/commands/README.md +++ b/api/apic/commands/README.md @@ -22,10 +22,10 @@ func Filter(prefix string) (result []*Command) Filter returns the filtered list of commands who's names match the specified prefix. -#### func Log +#### func Logf ```go -func Log(message string, args ...interface{}) +func Logf(message string, args ...interface{}) ``` Log prints message with the formatting args to stdout. diff --git a/api/apic/template/README.md b/api/apic/template/README.md index ee5b60ae1..202460046 100644 --- a/api/apic/template/README.md +++ b/api/apic/template/README.md @@ -23,30 +23,34 @@ var ( semantic.Float64Value(1.0), semantic.API{}, - semantic.ArrayIndex{}, - semantic.Array{}, + semantic.ArrayAssign{}, + semantic.ArrayInitializer{}, semantic.Assert{}, semantic.Assign{}, semantic.BinaryOp{}, semantic.BitTest{}, semantic.Branch{}, - semantic.Buffer{}, semantic.Builtin{}, semantic.Call{}, semantic.Cast{}, semantic.Choice{}, semantic.ClassInitializer{}, semantic.Class{}, + semantic.Clone{}, semantic.Copy{}, + semantic.Create{}, semantic.DeclareLocal{}, semantic.EnumEntry{}, semantic.Enum{}, + semantic.Fence{}, semantic.Field{}, semantic.Function{}, semantic.Global{}, + semantic.Ignore{}, semantic.Iteration{}, semantic.Length{}, semantic.Local{}, + semantic.Make{}, semantic.MapAssign{}, semantic.MapContains{}, semantic.MapIndex{}, @@ -56,14 +60,23 @@ var ( semantic.Null{}, semantic.Observed{}, semantic.Parameter{}, + semantic.PointerRange{}, semantic.Pointer{}, semantic.Pseudonym{}, + semantic.Read{}, + semantic.Reference{}, semantic.Return{}, semantic.Select{}, + semantic.SliceAssign{}, + semantic.SliceIndex{}, + semantic.SliceRange{}, + semantic.Slice{}, + semantic.Slice{}, semantic.StaticArray{}, semantic.Switch{}, semantic.UnaryOp{}, semantic.Unknown{}, + semantic.Write{}, (*semantic.Annotated)(nil), (*semantic.Expression)(nil), @@ -100,6 +113,34 @@ func (f *Functions) AllCommands(api interface{}) ([]interface{}, error) AllCommands returns a list of all cmd entries for a given API, regardless of whether they are free functions, class methods or pseudonym methods. +#### func (*Functions) Args + +```go +func (f *Functions) Args(arguments ...interface{}) (interface{}, error) +``` +Args builds a template argument object from a list of arguments. If no arguments +are passed then the result will be nil. If a single argument is passed then the +result will be the value of that argument. If the first argument is a map, it is +assumed to be a base argument set to be augmented. Remaining arguments must come +in name-value pairs. For example: + + {{define "SingleParameterMacro"}} + $ is: {{$}} + {{end}} + + {{define "MultipleParameterMacro"}} + $.ArgA is: {{$.ArgA}}, $.ArgB is: {{$.ArgB}} + {{end}} + + {{template "SingleParameterMacro" (Args)}} + {{/* Returns "$ is: nil" */}} + + {{template "SingleParameterMacro" (Args 42)}} + {{/* Returns "$ is: 42" */}} + + {{template "MultipleParameterMacro" (Args "ArgA" 4 "ArgB" 2)}} + {{/* Returns "$.ArgA is: 4, $.ArgB is: 2" */}} + #### func (*Functions) AssertType ```go @@ -163,15 +204,6 @@ GetAnnotation finds and returns the annotation on ty with the specified name. If the annotation cannot be found, or ty does not support annotations then GetAnnotation returns nil. -#### func (*Functions) GetArrayParamCount - -```go -func (*Functions) GetArrayParamCount(param *semantic.Parameter) interface{} -``` -GetArrayParamCount returns the inferred array size for param as a semantic -expression. If the array size cannot be inferred, then GetArrayParamCount -returns nil. - #### func (*Functions) Global ```go @@ -197,6 +229,13 @@ func (*Functions) HasMore(i int, l interface{}) bool ``` HasMore returns true if the i'th indexed item in l is not the last. +#### func (Functions) HasPrefix + +```go +func (Functions) HasPrefix(s string, prefix string) bool +``` +HasPrefix tests whether the string s begins with prefix. + #### func (*Functions) Include ```go @@ -220,12 +259,19 @@ func (f *Functions) IsNil(v interface{}) bool ``` IsNil returns true if v is nil. +#### func (*Functions) IsNumericType + +```go +func (*Functions) IsNumericType(t interface{}) bool +``` +Returns true if t is one of the primitive numeric types. + #### func (*Functions) IsNumericValue ```go func (*Functions) IsNumericValue(v interface{}) bool ``` -Returns true if v is one of the primitive numeric types. +Returns true if v is one of the primitive numeric value types. #### func (*Functions) Join @@ -265,27 +311,38 @@ Lower lower-cases all letters of each string segment. func (f *Functions) Macro(name string, arguments ...interface{}) (string, error) ``` Macro invokes the template macro with the specified name and returns the -template output as a string. If no arguments are passed then $ will be nil for -the called macro. If a single argument is passed then $ will be the value of -that argument. If more than one argument is passed then arguments is used as -name-value pairs, where name is a field on $. For example: +template output as a string. See Args for how the arguments are processed. - {{define "SingleParameterMacro"}} - $ is: {{$}} - {{end}} +#### func (*Functions) Node - {{define "MultipleParameterMacro"}} - $.ArgA is: {{$.ArgA}}, $.ArgB is: {{$.ArgB}} - {{end}} +```go +func (f *Functions) Node(prefix string, node interface{}, arguments ...interface{}) (string, error) +``` +Node dispatches to the template that matches the node best, writing the result +to the current output writer. If the node is a Type or Expression then the type +semantic.Type name is tried, then the class of type (the name of the semantic +class that represents the type). The actual name of the node type is then tried, +and if none of those matches, the "Default" template is used if present. If no +possible template could be matched, and error is generated. eg: {{Node +"TypeName" $}} where $ is a boolean and expression would try - {{Macro "SingleParameterMacro"}} - {{/* Returns "$ is: nil" */}} + "TypeName#Bool" + "TypeName.Builtin" + "TypeName.BinaryOp" + "TypeName_Default" - {{Macro "SingleParameterMacro" 42}} - {{/* Returns "$ is: 42" */}} +See Args for how the arguments are processed, in addition the Node arg will be +added in and have the value of node, and if the node had a type discovered, the +Type arg will be added in as well. - {{Macro "MultipleParameterMacro" "ArgA" 4 "ArgB" 2}} - {{/* Returns "$.ArgA is: 4, $.ArgB is: 2" */}} +#### func (*Functions) PackageOf + +```go +func (f *Functions) PackageOf(v semantic.Node) string +``` +PackageOf walks the ownership hierarchy to find the API that the supplied object +belongs to. If it is not the api being processed, then the import name of the +api is returned. #### func (*Functions) Reflow @@ -308,6 +365,14 @@ func (*Functions) Reverse(in interface{}) interface{} ``` Reverse returns a new list with all the elements of in reversed. +#### func (*Functions) SNode + +```go +func (f *Functions) SNode(prefix string, node interface{}, arguments ...interface{}) (string, error) +``` +SNode dispatches to the template that matches the node best, capturing the +result and returning it. See Node for the dispatch rules used. + #### func (*Functions) SortBy ```go @@ -354,6 +419,14 @@ func (*Functions) Tail(start int, array interface{}) interface{} ``` Tail returns a slice of the list from start to len(array). +#### func (*Functions) Template + +```go +func (f *Functions) Template(name string, arguments ...interface{}) (string, error) +``` +Template invokes the template with the specified name writing the output to the +current output writer. See Args for how the arguments are processed. + #### func (Functions) Title ```go diff --git a/api/ast/README.md b/api/ast/README.md index de56cf97d..fe158fbe7 100644 --- a/api/ast/README.md +++ b/api/ast/README.md @@ -13,29 +13,21 @@ const ( // meaning. KeywordAPI = "api" KeywordAlias = "alias" - KeywordArray = "array" - KeywordAs = "as" - KeywordAssert = "assert" KeywordBitfield = "bitfield" - KeywordBuffer = "buffer" KeywordCase = "case" KeywordClass = "class" KeywordCmd = "cmd" + KeywordConst = "const" KeywordElse = "else" KeywordEnum = "enum" KeywordExtern = "extern" KeywordFalse = "false" KeywordFor = "for" KeywordIf = "if" + KeywordImport = "import" KeywordIn = "in" - KeywordInout = "inout" - KeywordLength = "len" KeywordMacro = "macro" - KeywordMap = "map" - KeywordNew = "new" KeywordNull = "null" - KeywordOut = "out" - KeywordPointer = "ptr" KeywordReturn = "return" KeywordPseudonym = "type" KeywordSwitch = "switch" @@ -57,8 +49,6 @@ const ( OpListStart = "(" OpListSeparator = "," OpListEnd = ")" - OpMetaStart = "<" - OpMetaEnd = ">" OpAssign = "=" OpAssignPlus = "+=" OpAssignMinus = "-=" @@ -83,6 +73,7 @@ const ( OpRange = ".." OpNot = "!" OpIn = "in" + OpGeneric = "!" ) ``` @@ -106,6 +97,7 @@ var ( ```go type API struct { CST *parse.Branch // underlying parse structure for this node + Imports []*Import // api files imported with the "import" keyword Macros []*Function // functions declared with the "macro" keyword Externs []*Function // functions declared with the "extern" keyword Commands []*Function // functions declared with the "cmd" keyword @@ -173,25 +165,6 @@ type Annotations []*Annotation Annotations represents the set of Annotation objects that apply to another AST node. -#### type Assert - -```go -type Assert struct { - CST *parse.Branch // underlying parse structure for this node. - Condition Node // the condition to check, should be true -} -``` - -Assert represents the «"assert" condition» statement. Used mostly to express the -pre-conditions of api commands, such as acceptable values for parameters that -cannot be expressed in the type system. - -#### func (Assert) Fragment - -```go -func (t Assert) Fragment() parse.Fragment -``` - #### type Assign ```go @@ -326,24 +299,6 @@ statement value will be compared against. func (t Case) Fragment() parse.Fragment ``` -#### type Cast - -```go -type Cast struct { - CST *parse.Branch // underlying parse structure for this node - Object Node // the value to force the type of - Type Node // the type it should be coerced to -} -``` - -Cast represents a type coercion expression, of the form «expression "as" type» - -#### func (Cast) Fragment - -```go -func (t Cast) Fragment() parse.Fragment -``` - #### type Class ```go @@ -365,25 +320,6 @@ extension_list { fields }» func (t Class) Fragment() parse.Fragment ``` -#### type ClassInitializer - -```go -type ClassInitializer struct { - CST *parse.Branch // underlying parse structure for this node - Class *Identifier // the name of the class instantiate - Fields []*FieldInitializer // the initializers for the class fields -} -``` - -ClassInitializer represents a class literal declaration, of the form «name { -field_initializers }» - -#### func (ClassInitializer) Fragment - -```go -func (t ClassInitializer) Fragment() parse.Fragment -``` - #### type DeclareLocal ```go @@ -465,25 +401,6 @@ expression» func (t Field) Fragment() parse.Fragment ``` -#### type FieldInitializer - -```go -type FieldInitializer struct { - CST *parse.Branch // underlying parse structure for this node - Name *Identifier // the name of the field - Value Node // the value the field should be given -} -``` - -FieldInitializer is used as part of a ClassInitializer to specify the value a -single field should have. - -#### func (FieldInitializer) Fragment - -```go -func (t FieldInitializer) Fragment() parse.Fragment -``` - #### type Function ```go @@ -506,23 +423,23 @@ parameters is a comma separated list and body is an optional block. func (t Function) Fragment() parse.Fragment ``` -#### type GenericType +#### type Generic ```go -type GenericType struct { - CST *parse.Branch // underlying parse structure for this node - Generic *Identifier // the generic identifier. - Args []Node // the type arguments to the generic. +type Generic struct { + CST *parse.Branch // underlying parse structure for this node + Name *Identifier // the generic identifier. + Arguments []Node // the type arguments to the generic. } ``` -GenericType represents a generic type declaration, which looks like -«"array|map|buffer"<type {, type}>» +Generic represents a identifier modified by type arguments. It looks like: +«identifier ! ( arg | <arg {, arg} )>» -#### func (GenericType) Fragment +#### func (Generic) Fragment ```go -func (t GenericType) Fragment() parse.Fragment +func (t Generic) Fragment() parse.Fragment ``` #### type Group @@ -560,6 +477,43 @@ Identifier holds a parsed identifier in the parse tree. func (t Identifier) Fragment() parse.Fragment ``` +#### type Import + +```go +type Import struct { + CST *parse.Branch // underlying parse structure for this node + Annotations Annotations // the annotations applied to the import + Name *Identifier // the name to import an api file as + Path *String // the relative path to the api file +} +``` + +Import is the AST node that represents «import name "path"» constructs + +#### func (Import) Fragment + +```go +func (t Import) Fragment() parse.Fragment +``` + +#### type Imported + +```go +type Imported struct { + CST *parse.Branch // underlying parse structure for this node + From *Identifier // the import this name is from + Name *Identifier // the name being imported +} +``` + +Imported represents an imported type name. + +#### func (Imported) Fragment + +```go +func (t Imported) Fragment() parse.Fragment +``` + #### type Index ```go @@ -632,24 +586,6 @@ Iteration represents a «"for" variable "in" iterable { block }» structure. func (t Iteration) Fragment() parse.Fragment ``` -#### type Length - -```go -type Length struct { - CST *parse.Branch // underlying parse structure for this node. - Object Node // the object to query the length of -} -``` - -Length represents the «"len"(value)» construct, were value should be an -expresssion that returns an object of array, string or map type. - -#### func (Length) Fragment - -```go -func (t Length) Fragment() parse.Fragment -``` - #### type Member ```go @@ -669,23 +605,22 @@ form «object.name» where object is an expression. func (t Member) Fragment() parse.Fragment ``` -#### type New +#### type NamedArg ```go -type New struct { - CST *parse.Branch // underlying parse structure for this node - ClassInitializer *ClassInitializer +type NamedArg struct { + CST *parse.Branch // underlying parse structure for this node + Name *Identifier // the name of the parameter this value is for + Value Node // the value to use for that parameter } ``` -New represents an expression that allocates a new class instance and returns a -pointer to it. It takes a class initializer to specify both the type and the -initial value for the instance. +NamedArg represents a «name = value» expressionas a function argument. -#### func (New) Fragment +#### func (NamedArg) Fragment ```go -func (t New) Fragment() parse.Fragment +func (t NamedArg) Fragment() parse.Fragment ``` #### type Node @@ -739,8 +674,6 @@ func (t Number) Fragment() parse.Fragment type Parameter struct { CST *parse.Branch // underlying parse structure for this node Annotations Annotations // the annotations applied to this parameter - Input bool // true if the parameter is an input - Output bool // true if the parameters is an output This bool // true if the parameter is the this pointer of a method Type Node // the type of the parameter Name *Identifier // the name the parameter as exposed to the body @@ -760,8 +693,9 @@ func (t Parameter) Fragment() parse.Fragment ```go type PointerType struct { - CST *parse.Branch // underlying parse structure for this node - To Node // the underlying type this pointer points to + CST *parse.Branch // underlying parse structure for this node + To Node // the underlying type this pointer points to + Const bool // wether the pointer type has the const modifier applied } ``` diff --git a/api/parser/README.md b/api/parser/README.md index afbc4a756..4b2b194ca 100644 --- a/api/parser/README.md +++ b/api/parser/README.md @@ -10,7 +10,7 @@ syntax trees. #### func Parse ```go -func Parse(data string) (*ast.API, []parse.Error) +func Parse(data string) (*ast.API, parse.ErrorList) ``` Parse takes a string containing a complete api description and returns the abstract syntax tree representation of it. If the string is not syntactically diff --git a/api/resolver/README.md b/api/resolver/README.md index 992300b94..02cc9c591 100644 --- a/api/resolver/README.md +++ b/api/resolver/README.md @@ -8,16 +8,28 @@ graph ready for code generation. ## Usage +```go +const ( + RefSuffix = "ʳ" + SliceSuffix = "ˢ" + ConstSuffix = "ᶜ" + PointerSuffix = "ᵖ" + ArraySuffix = "ᵃ" + MapSuffix = "ᵐ" + TypeInfix = "ː" +) +``` + #### func Resolve ```go -func Resolve(compiled *ast.API) (*semantic.API, parse.ErrorList, ASTToSemantic) +func Resolve(includes []*ast.API, symbols *semantic.Symbols, mappings ASTToSemantic) (*semantic.API, parse.ErrorList) ``` -Resolve takes a valid ast as produced by the parser and converts it to the -semantic graph form. If the ast is not fully valid (ie there were parse errors) -then the results are undefined, and may include null pointer access. If there -are semantic problems with the ast, Resolve will return the set of errors it -finds, and the returned graph may be incomplete/invalid. +Resolve takes valid asts as produced by the parser and converts them to the +semantic graph form. If the asts are not fully valid (ie there were parse +errors) then the results are undefined. If there are semantic problems with the +ast, Resolve will return the set of errors it finds, and the returned graph may +be incomplete/invalid. #### type ASTToSemantic @@ -26,29 +38,3 @@ type ASTToSemantic map[ast.Node]semantic.Node ``` ASTToSemantic is a relational map of AST nodes to semantic nodes. - -#### type Alias - -```go -type Alias struct { - AST *ast.Alias - Name string - To semantic.Type -} -``` - -Alias is used as a temporary type holder during type resolution. It is not -present in the final semantic tree returned, but may be present in the AST -> -semantic map. - -#### func (Alias) Member - -```go -func (t Alias) Member(name string) semantic.Node -``` - -#### func (Alias) Typename - -```go -func (t Alias) Typename() string -``` diff --git a/api/semantic/README.md b/api/semantic/README.md index f0612da64..fbabcd4f0 100644 --- a/api/semantic/README.md +++ b/api/semantic/README.md @@ -38,29 +38,88 @@ var ( var BuiltinTypes []*Builtin ``` +#### func Add + +```go +func Add(p Owner, c Owned) +``` +Add connects an Owned to its Owner. + +#### func Visit + +```go +func Visit(node Node, visitor func(Node)) +``` +Visit invokes visitor for all the children of the supplied node. + #### type API ```go type API struct { - AST *ast.API // the underlying syntax node this was built from + Named Enums []*Enum // the set of enums Classes []*Class // the set of classes Pseudonyms []*Pseudonym // the set of pseudo types Externs []*Function // the external function references Functions []*Function // the global functions + Methods []*Function // the method functions Globals []*Global // the global variables - Arrays []*Array // the array types used StaticArrays []*StaticArray // the fixed size array types used Maps []*Map // the map types used Pointers []*Pointer // the pointer types used - Buffers []*Buffer // the buffer types used + Slices []*Slice // the pointer types used + References []*Reference // the reference types used Signatures []*Signature // the function signature types used - Members // a map of name to member for top level symbols + Imported *Symbols // the symbols imported into this api } ``` API is the root of the ASG, and holds a fully resolved api. +#### func (*API) Member + +```go +func (m *API) Member(name string) Owned +``` + +#### func (*API) VisitMembers + +```go +func (m *API) VisitMembers(visitor func(Owned)) +``` + +#### type Alias + +```go +type Alias struct { + AST *ast.Alias + Named + To Type +} +``` + +Alias is used as a temporary type holder during type resolution. It is not +present in the final semantic tree returned, but may be present in the AST -> +semantic map. + +#### func (Alias) Member + +```go +func (Alias) Member(string) Owned +``` + +#### func (*Alias) Owner + +```go +func (o *Alias) Owner() Owner +``` + +#### func (Alias) VisitMembers + +```go +func (Alias) VisitMembers(func(Owned)) +``` + #### type Annotated ```go @@ -77,7 +136,7 @@ Annotated is the common interface to objects that can carry annotations. ```go type Annotation struct { AST *ast.Annotation // the underlying syntax node this was built from - Name string // the name of the annotation + Named // the name of the annotation Arguments []Expression // the arguments to the annotation } ``` @@ -99,61 +158,78 @@ func (a Annotations) GetAnnotation(name string) *Annotation ``` GetAnnotation implements the Annotated interface for the Annotations type. -#### type Array +#### type ArrayAssign ```go -type Array struct { - Name string // the full name of the array type - ValueType Type // the value type stored in the array +type ArrayAssign struct { + AST *ast.Assign // the underlying syntax node this was built from + To *ArrayIndex // the array index to assign to + Operator string // the assignment operator being applied + Value Expression // the value to set in the array } ``` -Array represents an array type declaration. +ArrayAssign represents assigning to a static-array index expression. -#### func (Array) Member +#### type ArrayIndex ```go -func (t Array) Member(name string) Node +type ArrayIndex struct { + AST *ast.Index // the underlying syntax node this was built from + Type *StaticArray // the array type + Array Expression // the expression that returns the array to be indexed + Index Expression // the index to use on the array +} ``` -#### func (Array) Typename +ArrayIndex represents using the indexing operator on a static-array type. + +#### func (*ArrayIndex) ExpressionType ```go -func (t Array) Typename() string +func (i *ArrayIndex) ExpressionType() Type ``` +ExpressionType implements Expression. It returns the element type of the array. -#### type ArrayIndex +#### type ArrayInitializer ```go -type ArrayIndex struct { - AST *ast.Index // the underlying syntax node this was built from - ValueType Type // the value type of the array being indexed - Array Expression // the expression that returns the array to be indexed - Index Expression // the index to use on the array +type ArrayInitializer struct { + AST *ast.Call // the underlying syntax node this was built from + Array Type // the array type to initialize (may be aliased) + Values []Expression // the list of element values } ``` -ArrayIndex represents using the indexing operator on an array type. +ArrayInitializer represents an expression that creates a new StaticArray +instance using a value list, of the form T(v0, v1, v2) -#### func (*ArrayIndex) ExpressionType +#### func (*ArrayInitializer) ExpressionType ```go -func (i *ArrayIndex) ExpressionType() Type +func (c *ArrayInitializer) ExpressionType() Type ``` -ExpressionType implements Expression returning the value type of the array. +ExpressionType implements Expression returning the class type being initialized. #### type Assert ```go type Assert struct { - AST *ast.Assert // the underlying syntax node this was built from - Condition Expression // the condition is being asserted must be true + AST *ast.Call // the underlying syntax node this was built from + Condition Expression // the condition is being asserted must be true } ``` Assert represents a runtime assertion. Assertions are also used to infer required behavior from the expressions. +#### func (*Assert) ExpressionType + +```go +func (a *Assert) ExpressionType() Type +``` +ExpressionType implements Expression + #### type Assign ```go @@ -251,36 +327,11 @@ type Branch struct { Branch represents the basic conditional execution statement. If Condition is true we use the True block, otherwise the False block. -#### type Buffer - -```go -type Buffer struct { - Name string // the full type name - To Type // the type this is a pointer to - Array bool // points to multiple elements, rather than one - FakeArray *Array // TODO:Remove - Hold a fake array for now as a schema compatibility measure -} -``` - -Buffer represents a state pointer type declaration. - -#### func (Buffer) Member - -```go -func (t Buffer) Member(name string) Node -``` - -#### func (Buffer) Typename - -```go -func (t Buffer) Typename() string -``` - #### type Builtin ```go type Builtin struct { - Name string // the primitive type name + Named // the primitive type name } ``` @@ -289,13 +340,19 @@ Builtin represents one of the primitive types. #### func (Builtin) Member ```go -func (t Builtin) Member(name string) Node +func (Builtin) Member(string) Owned ``` -#### func (Builtin) Typename +#### func (*Builtin) Owner ```go -func (t Builtin) Typename() string +func (o *Builtin) Owner() Owner +``` + +#### func (Builtin) VisitMembers + +```go +func (Builtin) VisitMembers(func(Owned)) ``` #### type Call @@ -355,21 +412,20 @@ Case represents a possible choice in a switch. ```go type Cast struct { - AST *ast.Cast // the underlying syntax node this was built from - Object Expression // the actual expression being wrapped - Type Type // the type to coerce the expression to + AST *ast.Call // the underlying syntax node this was built from + Object Expression // the expression to cast the result of + Type Type // the type to cast to } ``` -Cast represents a type coercion expression. It reports it's type as the one -specified, rather than the expression it wraps. +Cast represents a type reinterpret expresssion. #### func (*Cast) ExpressionType ```go func (c *Cast) ExpressionType() Type ``` -ExpressionType implements Expression returning the type being cast to. +ExpressionType implements Expression #### type Choice @@ -389,32 +445,42 @@ Choice represents a possible choice in a select type Class struct { AST *ast.Class // the underlying syntax node this was built from Annotations // the annotations applied to this class - Name string // the name of the class + Named // implement Child Docs []string // the documentation for the class Extends []*Class // the classes this extends ExtendedBy []*Class // the classes that declared they extended this class Fields []*Field // the set of fields the class declares Methods []*Function // the set of functions associated with the class - Members // the name->member map, to implement Type } ``` Class represents an api class construct. -#### func (Class) Typename +#### func (*Class) Member ```go -func (t Class) Typename() string +func (m *Class) Member(name string) Owned +``` + +#### func (*Class) Owner + +```go +func (o *Class) Owner() Owner +``` + +#### func (*Class) VisitMembers + +```go +func (m *Class) VisitMembers(visitor func(Owned)) ``` -Implements Type to return the class name as the type name #### type ClassInitializer ```go type ClassInitializer struct { - AST *ast.ClassInitializer // the underlying syntax node this was built from - Class *Class // the class to initialize - Fields []*FieldInitializer // the set of field assignments + AST *ast.Call // the underlying syntax node this was built from + Class *Class // the class to initialize + Fields []*FieldInitializer // the set of field assignments } ``` @@ -428,19 +494,62 @@ func (c *ClassInitializer) ExpressionType() Type ``` ExpressionType implements Expression returning the class type being initialized. +#### type Clone + +```go +type Clone struct { + AST *ast.Call // the underlying syntax node this was built from + Slice Expression + Type *Slice +} +``` + +Clone represents a call to make. + +#### func (*Clone) ExpressionType + +```go +func (m *Clone) ExpressionType() Type +``` +ExpressionType implements Expression + #### type Copy ```go type Copy struct { - AST *ast.Assign // the underlying syntax node this was built from - Dst *Slice // the slice to copy to - Src *Slice // the slice to copy from + AST *ast.Call // the underlying syntax node this was built from + Src Expression + Dst Expression +} +``` + +Copy represents a call to make. + +#### func (*Copy) ExpressionType + +```go +func (*Copy) ExpressionType() Type +``` +ExpressionType implements Expression + +#### type Create + +```go +type Create struct { + AST *ast.Call // the underlying syntax node this was built from + Type *Reference + Initializer *ClassInitializer } ``` -Copy is the special form of assign that copies data between slices. One of LHS -or RHS may be missing, and if both are present the upper bound on one may be -inferred from the other. +Create represents a call to new on a class type. + +#### func (*Create) ExpressionType + +```go +func (n *Create) ExpressionType() Type +``` +ExpressionType implements Expression #### type DeclareLocal @@ -460,38 +569,40 @@ be modified after declaration. type Enum struct { AST *ast.Enum // the underlying syntax node this was built from Annotations // the annotations applied to this enum - Name string // the type name of the enum + Named // the type name of the enum Docs []string // the documentation for the enum IsBitfield bool // whether this enum is actually a bitfield Extends []*Enum // the enums this enum extends Entries []*EnumEntry // the entries of this enum - AllEntries []*EnumEntry // the flattened list of all entries including inherited ones } ``` Enum represents the api enum construct. -#### func (Enum) Member +#### func (*Enum) Member ```go -func (t Enum) Member(name string) Node +func (m *Enum) Member(name string) Owned ``` -Implements Type returning the matching enum entry if there is one. -#### func (Enum) Typename +#### func (*Enum) Owner ```go -func (t Enum) Typename() string +func (o *Enum) Owner() Owner +``` + +#### func (*Enum) VisitMembers + +```go +func (m *Enum) VisitMembers(visitor func(Owned)) ``` -Implements Type to return the enum name as the type name #### type EnumEntry ```go type EnumEntry struct { AST *ast.EnumEntry // the underlying syntax node this was built from - Enum *Enum // the enum this entry belongs to - Name string // the name of this entry + Named // the name of this entry Docs []string // the documentation for the enum entry Value uint32 // the value this entry represents } @@ -506,6 +617,12 @@ func (e *EnumEntry) ExpressionType() Type ``` ExpressionType implements Expression returning the enum type. +#### func (*EnumEntry) Owner + +```go +func (o *EnumEntry) Owner() Owner +``` + #### type Expression ```go @@ -519,15 +636,33 @@ Expression represents anything that can act as an expression in the api language, it must be able to correctly report the type of value it would return if executed. +#### type Fence + +```go +type Fence struct { + Statement Node +} +``` + +Fence is a marker to indicate the point between all statements to be executed +before (pre-fence) the call to the API function and all statements to be +executed after (post-fence) the call to the API function. + +The Statement member is the first statement that is classified as post-fence, +but may be nil if the fence is being added at the end of a function that has no +post operations. + +Note that some statements are classified as both pre-fence and post-fence, and +require logic to be executed either side of the API function call. + #### type Field ```go type Field struct { AST *ast.Field // the underlying syntax node this was built from Annotations // the annotations applied to this field - Class *Class // the class this field belongs to Type Type // the type the field stores - Name string // the name of the field + Named // the name of the field Docs []string // the documentation for the field Default Expression // the default value of the field } @@ -542,13 +677,19 @@ func (f *Field) ExpressionType() Type ``` Implements Expression to return the type stored in the field. +#### func (*Field) Owner + +```go +func (o *Field) Owner() Owner +``` + #### type FieldInitializer ```go type FieldInitializer struct { - AST *ast.FieldInitializer // the underlying syntax node this was built from - Field *Field // the field to assign to - Value Expression // the value to assign + AST ast.Node // the underlying syntax node this was built from + Field *Field // the field to assign to + Value Expression // the value to assign } ``` @@ -592,13 +733,11 @@ ExpressionType implements Expression with a type of Float64Type type Function struct { AST *ast.Function // the underlying syntax node this was built from Annotations // the annotations applied to the function - Name string // the name of the function + Named // the name of the function Docs []string // the documentation for the function - Owner Type // the owner of the function Return *Parameter // the return parameter This *Parameter // the this parameter, missing for non method functions FullParameters []*Parameter // all the parameters, including This at the start if valid, and Return at the end if not void - Outputs []*Parameter // only the output parameters Block *Block // the body of the function, missing for externs Signature *Signature // the type signature of the function } @@ -614,6 +753,12 @@ func (f *Function) CallParameters() []*Parameter CallParameters returns the full set of parameters with the return value filtered out. +#### func (*Function) Owner + +```go +func (o *Function) Owner() Owner +``` + #### type Global ```go @@ -621,7 +766,7 @@ type Global struct { AST *ast.Field // the underlying syntax node this was built from Annotations // the annotations applied to this global Type Type // the type the global stores - Name string // the name of the global + Named // the name of the global Default Expression // the initial value of the global } ``` @@ -635,6 +780,12 @@ func (g *Global) ExpressionType() Type ``` Implements Expression to return the type stored in the global. +#### func (*Global) Owner + +```go +func (o *Global) Owner() Owner +``` + #### type Ignore ```go @@ -652,6 +803,36 @@ func (i Ignore) ExpressionType() Type ``` ExpressionType implements Expression. +#### type Import + +```go +type Import struct { + Named // the full type name + API *API // the API being imported +} +``` + +Import wraps an API with it's imported name. + +#### func (Import) Member + +```go +func (i Import) Member(name string) Owned +``` +Implement the Owner interface delegating member lookup to the imported API + +#### func (*Import) Owner + +```go +func (o *Import) Owner() Owner +``` + +#### func (Import) VisitMembers + +```go +func (Import) VisitMembers(func(Owned)) +``` + #### type Int16Value ```go @@ -734,19 +915,20 @@ from Iterable in turn, and run Block for each one. ```go type Length struct { - AST *ast.Length // the underlying syntax node this was built from - Object Expression // the object go get the length of - Type Type // the resolved type of the length operation + AST *ast.Call // the underlying syntax node this was built from + Object Expression // the object go get the length of + Type Type // the resolved type of the length operation } ``` -Represents a length of object expression. Object must be of either Array, Map or -string type. The length expression is allowed to be of any numeric type +Length represents a length of object expression. Object must be of either +pointer, slice, map or string type. The length expression is allowed to be of +any numeric type -#### func (Length) ExpressionType +#### func (*Length) ExpressionType ```go -func (l Length) ExpressionType() Type +func (l *Length) ExpressionType() Type ``` ExpressionType implements Expression @@ -756,7 +938,7 @@ ExpressionType implements Expression type Local struct { Declaration *DeclareLocal // the statement that created the local Type Type // the type of the storage - Name string // the identifier that will resolve to this local + Named // the identifier that will resolve to this local Value Expression // the expression the local was assigned on creation } ``` @@ -771,23 +953,53 @@ func (l *Local) ExpressionType() Type ``` ExpressionType implements Expression +#### type Make + +```go +type Make struct { + AST *ast.Call // the underlying syntax node this was built from + Type *Slice + Size Expression +} +``` + +Make represents a call to make. + +#### func (*Make) ExpressionType + +```go +func (m *Make) ExpressionType() Type +``` +ExpressionType implements Expression + #### type Map ```go type Map struct { - Name string // the full type name - KeyType Type // the type used as an indexing key - ValueType Type // the type stored in the map - Members // holds the map built-in methods + Named // the full type name + KeyType Type // the type used as an indexing key + ValueType Type // the type stored in the map } ``` -Map represents an api map type declaration. +Map represents an api map type declaration, of the form map!(KeyType, ValueType) + +#### func (*Map) Member + +```go +func (m *Map) Member(name string) Owned +``` -#### func (Map) Typename +#### func (*Map) Owner ```go -func (t Map) Typename() string +func (o *Map) Owner() Owner +``` + +#### func (*Map) VisitMembers + +```go +func (m *Map) VisitMembers(visitor func(Owned)) ``` #### type MapAssign @@ -826,10 +1038,10 @@ ExpressionType implements Expression ```go type MapIndex struct { - AST *ast.Index // the underlying syntax node this was built from - ValueType Type // the value type of the array being indexed - Map Expression // the expression that returns the map to be indexed - Index Expression // the index to use on the map + AST *ast.Index // the underlying syntax node this was built from + Type *Map // the value type of the map being indexed + Map Expression // the expression that returns the map to be indexed + Index Expression // the index to use on the map } ``` @@ -861,41 +1073,48 @@ func (m *Member) ExpressionType() Type ``` ExpressionType implements Expression returning the type of the field. -#### type Members +#### type Named ```go -type Members map[string]Node +type Named string ``` -Members wraps a map and implements part of the Type interface. It is used as a -mixin helper. +Named is mixed in to implement the Name method of NamedNode. -#### func (Members) Member +#### func (Named) Name ```go -func (t Members) Member(name string) Node +func (n Named) Name() string ``` -Member returns the entry in the map that matches name, or nil if none does. + +#### type NamedNode + +```go +type NamedNode interface { + Node + Name() string // Returns the partial name of the object. +} +``` + +NamedNode represents any semantic-tree node that carries a name. #### type New ```go type New struct { - AST *ast.New // the underlying syntax node this was built from - Initializer *ClassInitializer // The initialization for the new instance - Type Type // The pointer type returned from the new + AST *ast.Call // the underlying syntax node this was built from + Type *Reference } ``` -New represents an expression that allocates a new class instance. +New represents a call to new. #### func (*New) ExpressionType ```go func (n *New) ExpressionType() Type ``` -ExpressionType implements Expression returning a pointer to the class type being -initialized. +ExpressionType implements Expression #### type Node @@ -942,6 +1161,31 @@ func (e *Observed) ExpressionType() Type ``` ExpressionType implements Expression for observed parameter lookup. +#### type Owned + +```go +type Owned interface { + NamedNode + Owner() Owner // Returns the owner of this node. + // contains filtered or unexported methods +} +``` + +Owned is the interface to an object with a unique name and an owner. + +#### type Owner + +```go +type Owner interface { + NamedNode + Member(string) Owned // looks up a member by name from an owner + VisitMembers(func(Owned)) // invokes the supplied function once for each member + // contains filtered or unexported methods +} +``` + +Owner is the interface for an object that has named members. + #### type Parameter ```go @@ -949,10 +1193,8 @@ type Parameter struct { AST *ast.Parameter // the underlying syntax node this was built from Annotations // the annotations applied to the parameter Function *Function // the function this parameter belongs to - Name string // the name of the parameter + Named // the name of the parameter Docs []string // the documentation for the parameter - Input bool // true if the parameter is an input - Output bool // true if the parameter is an output Type Type // the type of the parameter } ``` @@ -977,57 +1219,137 @@ IsThis returns true if this parameter is the This parameter of it's function. ```go type Pointer struct { - Name string // the full type name + Named // the full type name To Type // the type this is a pointer to - Array bool // points to multiple elements, rather than one + Const bool // wether the pointer was declared with the const attribute + Slice *Slice // The complementary slice type for this pointer. } ``` -Pointer represents an api pointer type declaration. +Pointer represents an api pointer type declaration, of the form To* -#### func (Pointer) Member +#### func (*Pointer) Member ```go -func (t Pointer) Member(name string) Node +func (t *Pointer) Member(name string) Owned ``` -#### func (Pointer) Typename +#### func (*Pointer) Owner ```go -func (t Pointer) Typename() string +func (o *Pointer) Owner() Owner ``` +#### func (*Pointer) VisitMembers + +```go +func (t *Pointer) VisitMembers(visitor func(Owned)) +``` + +#### type PointerRange + +```go +type PointerRange struct { + AST *ast.Index // the underlying syntax node this was built from + Type *Slice // the slice type returned. + Pointer Expression // the expression that returns the pointer to be indexed + Range *BinaryOp // the range to use on the slice +} +``` + +PointerRange represents using the indexing operator on a pointer type with a +range expression. + +#### func (*PointerRange) ExpressionType + +```go +func (i *PointerRange) ExpressionType() Type +``` +ExpressionType implements Expression. It returns the same slice type being +sliced. + #### type Pseudonym ```go type Pseudonym struct { AST *ast.Pseudonym // the underlying syntax node this was built from Annotations // the annotations applied to this pseudonym - Name string // the type name + Named // the type name Docs []string // the documentation for the pseudonym To Type // the underlying type Methods []*Function // the methods added directly to the pseudonym - Members // the direct members } ``` Pseudonym represents the type construct. It acts as a type in it's own right that can carry methods, but is defined in terms of another type. -#### func (Pseudonym) Member +#### func (*Pseudonym) Member ```go -func (t Pseudonym) Member(name string) Node +func (t *Pseudonym) Member(name string) Owned ``` Implements Type returning the direct member if it has it, otherwise delegating the lookup to the underlying type. -#### func (Pseudonym) Typename +#### func (*Pseudonym) Owner + +```go +func (o *Pseudonym) Owner() Owner +``` + +#### func (*Pseudonym) VisitMembers + +```go +func (t *Pseudonym) VisitMembers(visitor func(Owned)) +``` + +#### type Read + +```go +type Read struct { + AST *ast.Call // the underlying syntax node this was built from + Slice Expression +} +``` + +Read represents a call to make. + +#### func (*Read) ExpressionType + +```go +func (*Read) ExpressionType() Type +``` +ExpressionType implements Expression + +#### type Reference + +```go +type Reference struct { + Named // the full type name + To Type // the type this is a reference to +} +``` + +Reference represents an api reference type declaration, of the form ref!To + +#### func (*Reference) Member + +```go +func (t *Reference) Member(name string) Owned +``` + +#### func (*Reference) Owner + +```go +func (o *Reference) Owner() Owner +``` + +#### func (*Reference) VisitMembers ```go -func (t Pseudonym) Typename() string +func (t *Reference) VisitMembers(visitor func(Owned)) ``` -Implements Type to return the type name #### type Return @@ -1065,7 +1387,7 @@ ExpressionType implements Expression with the unified type of the choices ```go type Signature struct { - Name string // the full type name + Named // the full type name Return Type // the return type of the callable Arguments []Type // the required callable arguments } @@ -1076,58 +1398,135 @@ Signature represents a callable type signature #### func (Signature) Member ```go -func (Signature) Member(name string) Node +func (Signature) Member(string) Owned ``` -#### func (Signature) Typename +#### func (*Signature) Owner ```go -func (t Signature) Typename() string +func (o *Signature) Owner() Owner +``` + +#### func (Signature) VisitMembers + +```go +func (Signature) VisitMembers(func(Owned)) ``` #### type Slice ```go type Slice struct { + Named // the full type name + To Type // The type this is a slice of + Pointer *Pointer // The complementary pointer type for this slice. +} +``` + +Slice represents an api slice type declaration, of the form To[] + +#### func (Slice) Member + +```go +func (Slice) Member(string) Owned +``` + +#### func (*Slice) Owner + +```go +func (o *Slice) Owner() Owner +``` + +#### func (Slice) VisitMembers + +```go +func (Slice) VisitMembers(func(Owned)) +``` + +#### type SliceAssign + +```go +type SliceAssign struct { + AST *ast.Assign // the underlying syntax node this was built from + To *SliceIndex // the slice index to assign to + Operator string // the assignment operator being applied + Value Expression // the value to set in the slice +} +``` + +SliceAssign represents assigning to a slice index expression. + +#### type SliceIndex + +```go +type SliceIndex struct { + AST *ast.Index // the underlying syntax node this was built from + Type *Slice // the slice type + Slice Expression // the expression that returns the slice to be indexed + Index Expression // the index to use on the slice +} +``` + +SliceIndex represents using the indexing operator on a slice type. + +#### func (*SliceIndex) ExpressionType + +```go +func (i *SliceIndex) ExpressionType() Type +``` +ExpressionType implements Expression. It returns the value type of the slice. + +#### type SliceRange + +```go +type SliceRange struct { AST *ast.Index // the underlying syntax node this was built from - Array Expression // the expression that returns the array to be indexed - Lower Expression // the inclusive lower bound to slice at - Upper Expression // the non-inclusive upper bound to slice at + Type *Slice // the slice type + Slice Expression // the expression that returns the slice to be indexed + Range *BinaryOp // the range to use on the slice } ``` -Slice represents using the slicing operator on an array type. +SliceRange represents using the indexing operator on a slice type with a range +expression. -#### func (*Slice) ExpressionType +#### func (*SliceRange) ExpressionType ```go -func (i *Slice) ExpressionType() Type +func (i *SliceRange) ExpressionType() Type ``` -ExpressionType implements Expression. It returns VoidType as slices are only -valid in Copy assignments. +ExpressionType implements Expression. It returns the same slice type being +sliced. #### type StaticArray ```go type StaticArray struct { - Name string // the full type name + Named // the full type name ValueType Type // the storage type of the elements Size uint32 // the dimension of the array } ``` -StaticArray represents a multi-dimensional fixed size array type. +StaticArray represents a multi-dimensional fixed size array type, of the form +T[8] #### func (StaticArray) Member ```go -func (t StaticArray) Member(name string) Node +func (StaticArray) Member(string) Owned +``` + +#### func (*StaticArray) Owner + +```go +func (o *StaticArray) Owner() Owner ``` -#### func (StaticArray) Typename +#### func (StaticArray) VisitMembers ```go -func (t StaticArray) Typename() string +func (StaticArray) VisitMembers(func(Owned)) ``` #### type StringValue @@ -1158,13 +1557,53 @@ type Switch struct { Switch represents a resolved ast.Switch statement. +#### type Symbols + +```go +type Symbols struct { +} +``` + +Symbols is an object with named members and no other functionality. + +#### func (*Symbols) Add + +```go +func (s *Symbols) Add(name string, entry Node) +``` +Add inserts a node into the symbol space with the specified name. + +#### func (*Symbols) AddNamed + +```go +func (s *Symbols) AddNamed(entry NamedNode) +``` +Add inserts a named node into the symbol space. + +#### func (*Symbols) Find + +```go +func (s *Symbols) Find(name string) (Node, error) +``` + +#### func (*Symbols) FindAll + +```go +func (s *Symbols) FindAll(name string) []Node +``` + +#### func (*Symbols) Visit + +```go +func (s *Symbols) Visit(visitor func(string, Node)) +``` + #### type Type ```go type Type interface { - Node - Typename() string // returns the full name of the type, must be unique - Member(Name string) Node // looks up a member by name from a type + Owner + // contains filtered or unexported methods } ``` @@ -1276,3 +1715,21 @@ func (u Unknown) ExpressionType() Type ExpressionType implements Expression with the inferred type of the unknown. If the unknown could not be inferred, it will be of type "any" so allow expressions using it to resolve anyway. + +#### type Write + +```go +type Write struct { + AST *ast.Call // the underlying syntax node this was built from + Slice Expression +} +``` + +Write represents a call to make. + +#### func (*Write) ExpressionType + +```go +func (*Write) ExpressionType() Type +``` +ExpressionType implements Expression diff --git a/atom/README.md b/atom/README.md index 7b7718446..cf8a503d4 100644 --- a/atom/README.md +++ b/atom/README.md @@ -11,6 +11,15 @@ const NoID = ^ID(0) ``` NoID is used when you have to pass an ID, but don't have one to use. +#### func Data + +```go +func Data(a device.Architecture, d database.Database, l log.Logger, at memory.Pointer, v ...interface{}) (memory.Range, binary.ID) +``` +Data encodes and stores the value v to the database d, returning the memory +range and new resource identifier. Data can be used to as a helper to AddRead +and AddWrite methods on atoms. + #### func Register ```go @@ -34,8 +43,11 @@ type Atom interface { // Flags returns the flags of the atom. Flags() Flags + // Observations returns all the memory observations made by the atom. + Observations() *Observations + // Mutate mutates the State using the atom. - Mutate(*gfxapi.State) error + Mutate(*gfxapi.State, database.Database, log.Logger) error } ``` @@ -85,6 +97,18 @@ func (f Flags) IsEndOfFrame() bool ``` IsEndOfFrame returns true if the atom represents the end of a frame. +#### func (*Flags) Parse + +```go +func (v *Flags) Parse(s string) error +``` + +#### func (Flags) String + +```go +func (v Flags) String() string +``` + #### type Group ```go @@ -150,18 +174,18 @@ Count returns the number of immediate items this group contains. ```go func (g Group) Index(index uint64) (baseAtomID ID, subgroup *Group) ``` -Index returns the item with the specified index. If the item refers directly to -an atom identifier then the atom identifier is returned in baseAtomID and -subgroup is assigned nil. If the item is a sub-group then baseAtomID is returned -as the lowest atom identifier found in the sub-group and subgroup is assigned -the sub-group pointer. +Index returns the item at the specified index. If the item refers directly to an +atom identifier then the atom identifier is returned in baseAtomID and subgroup +is assigned nil. If the item is a sub-group then baseAtomID is returned as the +lowest atom identifier found in the sub-group and subgroup is assigned the +sub-group pointer. #### func (Group) IndexOf ```go func (g Group) IndexOf(atomID ID) uint64 ``` -IndexOf returns the item index that refers directly to, or contains the given +IndexOf returns the item index that ID refers directly to, or contains the given atom identifer. #### func (*Group) Insert @@ -261,6 +285,18 @@ type ID uint64 ID is the index of an atom in an atom stream. +#### func (*ID) Parse + +```go +func (v *ID) Parse(s string) error +``` + +#### func (ID) String + +```go +func (v ID) String() string +``` + #### type IDSet ```go @@ -303,9 +339,10 @@ List is a list of atoms. #### func (*List) Add ```go -func (l *List) Add(a Atom) +func (l *List) Add(a ...Atom) ID ``` -Add adds a to the end of the atom list. +Add appends a to the end of the atom list, returning the id of the last added +atom. #### func (*List) AddAt @@ -347,49 +384,62 @@ WriteTo writes all atoms in the list to w, terminating with a single EOS atom. ```go type Observation struct { binary.Generate - Range memory.Range // The memory range that was observed. - ResourceID binary.ID // The resource identifier holding the memory that was observed. + Range memory.Range // Memory range that was observed. + ID binary.ID // The resource identifier of the observed data. } ``` -Observation is an Atom describing a region of application space memory that was -observed at capture time. +Observation represents a single read or write observation made by an atom. + +#### func (*Observation) Class + +```go +func (*Observation) Class() binary.Class +``` -#### func (*Observation) API +#### func (Observation) String ```go -func (a *Observation) API() gfxapi.API +func (o Observation) String() string ``` -Atom compliance -#### func (*Observation) Class +#### type Observations ```go -func (*Observation) Class() binary.Class +type Observations struct { + binary.Generate + Reads []Observation + Writes []Observation +} ``` -#### func (*Observation) Flags +Observations is a collection of reads and write observations performed by an +atom. + +#### func (Observations) ApplyReads ```go -func (a *Observation) Flags() Flags +func (o Observations) ApplyReads(p *memory.Pool) ``` +ApplyReads applies all the observed reads to memory pool p. -#### func (*Observation) Mutate +#### func (Observations) ApplyWrites ```go -func (a *Observation) Mutate(s *gfxapi.State) error +func (o Observations) ApplyWrites(p *memory.Pool) ``` +ApplyReads applies all the observed writes to the memory pool p. -#### func (*Observation) String +#### func (*Observations) Class ```go -func (a *Observation) String() string +func (*Observations) Class() binary.Class ``` -#### func (*Observation) TypeID +#### func (Observations) String ```go -func (a *Observation) TypeID() TypeID +func (o Observations) String() string ``` #### type Range @@ -514,14 +564,14 @@ SetSpan sets the atom identifier span for the group at index in the list. ```go type Resource struct { binary.Generate - ResourceID binary.ID // The resource identifier holding the memory that was observed. - Data []byte // The resource data + ID binary.ID // The resource identifier holding the memory that was observed. + Data []byte // The resource data } ``` -Resource is an Atom that embeds a blob of memory into the stream. These atoms -are typically only used for .gfxtrace files as they are stripped from the stream -on import and placed into the database. +Resource is an Atom that embeds a blob of memory into the atom stream. These +atoms are typically only used for .gfxtrace files as they are stripped from the +stream on import and their resources are placed into the database. #### func (*Resource) API @@ -545,7 +595,13 @@ func (a *Resource) Flags() Flags #### func (*Resource) Mutate ```go -func (a *Resource) Mutate(s *gfxapi.State) error +func (a *Resource) Mutate(s *gfxapi.State, d database.Database, l log.Logger) error +``` + +#### func (*Resource) Observations + +```go +func (a *Resource) Observations() *Observations ``` #### func (*Resource) String @@ -598,7 +654,7 @@ Transforms is a list of Transformer objects. func (l *Transforms) Add(t ...Transformer) ``` Add is a convenience function for appending the list of Transformers t to the -end of the Transforms list. +end of the Transforms list, after filtering out nil Transformers. #### func (Transforms) Transform @@ -624,11 +680,19 @@ const TypeIDEos TypeID = 0xffff TypeIDEos is used as a special end of stream marker. ```go -const TypeIDObservation TypeID = 0xfffe +const TypeIDResource TypeID = 0xfffd ``` +#### func (*TypeID) Parse + ```go -const TypeIDResource TypeID = 0xfffd +func (v *TypeID) Parse(s string) error +``` + +#### func (TypeID) String + +```go +func (v TypeID) String() string ``` #### type TypeInfo diff --git a/atom/test/README.md b/atom/test/README.md index ed46fa230..3decbe93b 100644 --- a/atom/test/README.md +++ b/atom/test/README.md @@ -18,13 +18,21 @@ const AtomIDB = atom.TypeID(2) const AtomIDC = atom.TypeID(3) ``` +```go +var ( + AtomAID = binary.ID{0x38, 0x1e, 0xef, 0x73, 0x50, 0xa0, 0x48, 0x6d, 0xa3, 0x1d, 0x8e, 0xb6, 0x5e, 0x47, 0xb7, 0xbf, 0x7b, 0xc8, 0x06, 0x33} + AtomBID = binary.ID{0x32, 0x6a, 0x98, 0x0f, 0x59, 0xd2, 0x52, 0x34, 0x9c, 0xc2, 0x75, 0x25, 0x62, 0xb8, 0xb3, 0x0b, 0x48, 0x54, 0x3c, 0x85} + AtomCID = binary.ID{0x02, 0x32, 0xdd, 0xd7, 0x4d, 0x7e, 0xbf, 0x43, 0x41, 0x47, 0xbb, 0xcb, 0xd8, 0xed, 0xd4, 0xd8, 0xb4, 0x42, 0xf9, 0xd5} +) +``` + #### type AtomA ```go type AtomA struct { - binary.Generate - ID atom.ID - AtomFlags atom.Flags + binary.Generate `id:"AtomAID"` + ID atom.ID + AtomFlags atom.Flags } ``` @@ -50,7 +58,13 @@ func (a *AtomA) Flags() atom.Flags #### func (*AtomA) Mutate ```go -func (a *AtomA) Mutate(*gfxapi.State) error +func (a *AtomA) Mutate(*gfxapi.State, database.Database, log.Logger) error +``` + +#### func (*AtomA) Observations + +```go +func (a *AtomA) Observations() *atom.Observations ``` #### func (*AtomA) TypeID @@ -63,9 +77,9 @@ func (a *AtomA) TypeID() atom.TypeID ```go type AtomB struct { - binary.Generate - ID atom.ID - Bool bool + binary.Generate `id:"AtomBID"` + ID atom.ID + Bool bool } ``` @@ -91,7 +105,13 @@ func (a *AtomB) Flags() atom.Flags #### func (*AtomB) Mutate ```go -func (a *AtomB) Mutate(*gfxapi.State) error +func (a *AtomB) Mutate(*gfxapi.State, database.Database, log.Logger) error +``` + +#### func (*AtomB) Observations + +```go +func (a *AtomB) Observations() *atom.Observations ``` #### func (*AtomB) TypeID @@ -104,8 +124,8 @@ func (a *AtomB) TypeID() atom.TypeID ```go type AtomC struct { - binary.Generate - String string + binary.Generate `id:"AtomCID"` + String string } ``` @@ -131,7 +151,13 @@ func (a *AtomC) Flags() atom.Flags #### func (*AtomC) Mutate ```go -func (a *AtomC) Mutate(*gfxapi.State) error +func (a *AtomC) Mutate(*gfxapi.State, database.Database, log.Logger) error +``` + +#### func (*AtomC) Observations + +```go +func (a *AtomC) Observations() *atom.Observations ``` #### func (*AtomC) TypeID diff --git a/atom/transform/README.md b/atom/transform/README.md index 601c6a738..e1ac78da9 100644 --- a/atom/transform/README.md +++ b/atom/transform/README.md @@ -56,7 +56,7 @@ func (t *Injector) Flush(out atom.Writer) #### func (*Injector) Inject ```go -func (t *Injector) Inject(after atom.ID, id atom.ID, a atom.Atom) +func (t *Injector) Inject(after atom.ID, a atom.Atom) ``` Inject emits the atom a with identifier id after the atom with identifier after. diff --git a/binary/README.md b/binary/README.md index 1ec19379a..c0072c011 100644 --- a/binary/README.md +++ b/binary/README.md @@ -26,6 +26,36 @@ const IDSize = 20 ``` IDSize is the size of an ID. +#### func ReadInt + +```go +func ReadInt(r Reader, bits int) (int64, error) +``` +ReadInt reads a signed integer of either 8, 16, 32 or 64 bits from r, returning +the result as a int64. + +#### func ReadUint + +```go +func ReadUint(r Reader, bits int) (uint64, error) +``` +ReadUint reads an unsigned integer of either 8, 16, 32 or 64 bits from r, +returning the result as a uint64. + +#### func WriteInt + +```go +func WriteInt(w Writer, bits int, v int64) error +``` +WriteInt writes the signed integer v of either 8, 16, 32 or 64 bits to w. + +#### func WriteUint + +```go +func WriteUint(w Writer, bits int, v uint64) error +``` +WriteUint writes the unsigned integer v of either 8, 16, 32 or 64 bits to w. + #### type BitStream ```go @@ -80,6 +110,9 @@ type Class interface { // fields causes it's id to change. ID() ID + // New can be used to build a new default initialized instance of the type. + New() Object + // Encode writes the supplied object to the supplied Encoder. // The object must be a type the Class understands, the implementation is // allowed to panic if it is not. @@ -305,7 +338,7 @@ Object is the interface to any class that wants to be encoded/decoded. ```go type Reader interface { - // Data writes the data bytes in their entirety. + // Data reads the data bytes in their entirety. Data([]byte) error // Skip jumps past count bytes. Skip(count uint32) error diff --git a/binary/generate/README.md b/binary/generate/README.md index d522dde3d..3a1df0752 100644 --- a/binary/generate/README.md +++ b/binary/generate/README.md @@ -33,30 +33,19 @@ type Directory struct { ``` -#### type Field - -```go -type Field struct { - // Name is the true field name. - Name string // The name the field was given. - Type *Type // A description of the type of the field. - Anonymous bool // Whether the field was anonymous. -} -``` - -Field holds a description of a single Struct member. - #### type File ```go type File struct { - Generated string - Package string - Import string - IsTest bool - Path string - Structs []*Struct - Imports Imports + Copyright string + Package string + Import string + IsTest bool + Path string + Directives map[string]string + Structs []*Struct + Constants schema.Constants + Imports Imports Style } ``` @@ -76,6 +65,13 @@ type Generator struct { func NewGenerator() *Generator ``` +#### func (*Generator) CppFile + +```go +func (g *Generator) CppFile(file *File) ([]byte, error) +``` +CppFile generates the all the cpp code for a file with a set of structs. + #### func (*Generator) GoFile ```go @@ -97,50 +93,6 @@ type Imports map[string]struct{} ``` -#### type Kind - -```go -type Kind int -``` - -Kind describes the basic nature of a type. - -```go -const ( - // Native is the kind for primitive types with corresponding direct methods on - // Encoder and Decoder - Native Kind = iota - // Remap is the kind for a type declared as alias to a primitive type. - // For example: type U32 uint32. - Remap - // Codeable is the kind for a direct in place struct. - Codeable - // Pointer is the kind for a pointer to a struct type. If the struct instance - // has equality (==) with a previously encoded object, then this struct will - // be encoded as a reference to the first encoded object. - Pointer - // Array is the kind for an in place slice, with a dynamic length. - Array - // StaticArray is the kind for an in place array, with a fixed length. - StaticArray - // Stream is the kind for an in place slice, with a Terminator. - Stream - // Interface is the kind for an object boxed in an binary.Object interface - // (or superset of). If the object has equality (==) with a previously - // encoded object, then this object may be encoded as a reference to the - // first encoded object. - Interface - // Map is the kind for a key value map. - Map -) -``` - -#### func (Kind) String - -```go -func (i Kind) String() string -``` - #### type Loader ```go @@ -211,8 +163,10 @@ must be considered separately because otherwise you can get import cycles. ```go type Source struct { - Filename string // The filename for this source - Content interface{} // The content of this source, see ParseFiles for details. + Filename string // The filename for this source + Content interface{} // The content of this source, see ParseFiles for details. + AST *ast.File // The parsed syntax tree + Directives map[string]string // the set of comment overrides } ``` @@ -222,12 +176,9 @@ Source holds a file a filename content pair as consumed by go/parser.ParseFile. ```go type Struct struct { - Name string // The simple name of the type. - IDName string // The name to give the ID of the type. - Package string // The package name the struct belongs to. - Fields []Field // Descriptions of the fields of the struct. - Signature string // The full string type signature of the Struct. - ID binary.ID // The unique type identifier for the Struct. + schema.Class + IDName string // The name to give the ID of the type. + Signature string // The full string type signature of the Struct. } ``` @@ -260,21 +211,3 @@ type Style struct { Indent string } ``` - - -#### type Type - -```go -type Type struct { - Name string // The name of the type. - Native string // The go native name of the type. - Kind Kind // The types basic Kind. - KeyType *Type // If the type is a Map, holds the key type. - SubType *Type // If the type is an Array, Map, Pointer or StaticArray, holds the element type. - Length int // If the type is a StaticArray, holds the fixed array size. - Method string // The encode/decode method to use. - SkipMethod string // The skip method to use. -} -``` - -Type is used to describe fields of a struct. diff --git a/binary/objects/README.md b/binary/objects/README.md index 1ee125e65..1b929648e 100644 --- a/binary/objects/README.md +++ b/binary/objects/README.md @@ -14,16 +14,14 @@ var ( ```go var ( - TerminatorID = binary.ID{0x67, 0x56, 0x42, 0x64, 0x1b, 0xc7, 0xa0, 0xf4, 0x8d, 0xe1, 0x64, 0xc0, 0x4d, 0x22, 0x9b, 0xa8, 0x13, 0xb2, 0x70, 0xea} + TerminatorID = binary.ID{0x01} ) ``` #### type Terminator ```go -type Terminator struct { - binary.Generate `id:"TerminatorID"` -} +type Terminator struct{} ``` Terminator is an object with no payload who's purpose is to mark the end of a an diff --git a/binary/registry/README.md b/binary/registry/README.md index 26fc5e29c..2ba6b2143 100644 --- a/binary/registry/README.md +++ b/binary/registry/README.md @@ -50,6 +50,15 @@ func (n Namespace) Add(class binary.Class) ``` Add a new type to the Namespace. +#### func (Namespace) Count + +```go +func (n Namespace) Count() int +``` +Count returns the number of entries reachable through this namespace. Because it +sums the counts of the namespaces it depends on, this may be more than the +number of unique keys. + #### func (Namespace) Lookup ```go @@ -57,3 +66,12 @@ func (n Namespace) Lookup(id binary.ID) binary.Class ``` Lookup looks up a Class by the given type id in the Namespace. If there is no match, it will return nil. + +#### func (Namespace) Visit + +```go +func (n Namespace) Visit(visitor func(binary.ID, binary.Class)) +``` +Visit invokes the visitor for every id and class pair reachable through this +namespace. The visitor maybe be called with the same id more than once if it is +present in multiple namespaces. diff --git a/binary/test/README.md b/binary/test/README.md index 8d315208e..84b711729 100644 --- a/binary/test/README.md +++ b/binary/test/README.md @@ -6,6 +6,13 @@ ## Usage ```go +var ( + TypeAID = binary.ID{0xa4, 0xbe, 0x00, 0x04, 0x4c, 0x84, 0x76, 0x86, 0xdc, 0x77, 0x63, 0x6d, 0x19, 0xdd, 0x63, 0x33, 0x17, 0x38, 0xbf, 0x24} + TypeBID = binary.ID{0x73, 0xbd, 0xff, 0x55, 0x9c, 0xc4, 0x5b, 0xe3, 0xaf, 0x72, 0xfd, 0xb6, 0x97, 0xfb, 0x0e, 0xe1, 0x8d, 0x19, 0xa9, 0x67} +) +``` + +```go var BadObject = &BadType{data: "BadObject"} ``` @@ -56,6 +63,27 @@ type BadType struct { ``` +#### type Bytes + +```go +type Bytes struct { + Data []byte +} +``` + + +#### func (Bytes) Add + +```go +func (b Bytes) Add(data ...byte) Bytes +``` + +#### func (Bytes) ID + +```go +func (b Bytes) ID(id binary.ID) Bytes +``` + #### type Entry ```go @@ -71,7 +99,7 @@ type Entry struct { ```go type TypeA struct { - binary.Generate + binary.Generate `id:"TypeAID"` } ``` @@ -86,7 +114,7 @@ func (*TypeA) Class() binary.Class ```go type TypeB struct { - binary.Generate + binary.Generate `id:"TypeBID"` } ``` diff --git a/build/README.md b/build/README.md index 0a7feeef8..82ef72e3f 100644 --- a/build/README.md +++ b/build/README.md @@ -7,30 +7,6 @@ Package build contains types and variables used for creating builds. ## Usage ```go -const HostExecutableExtension = "" -``` - -```go -const HostExecutableExtension = "" -``` - -```go -const HostExecutableExtension = ".exe" -``` - -```go -const HostOS = "linux" -``` - -```go -const HostOS = "osx" -``` - -```go -const HostOS = "windows" -``` - -```go var RepoRoot = func() Root { gopaths := filepath.SplitList(os.Getenv("GOPATH")) for _, gopath := range gopaths { @@ -104,13 +80,6 @@ func (f File) CopyTo(dst File) error ``` CopyTo copied this File to dst, replacing any existing file at dst. -#### func (File) Delete - -```go -func (f File) Delete() error -``` -Delete deletes the File. - #### func (File) Dir ```go @@ -162,13 +131,6 @@ func (f File) Join(ext ...string) File ``` Join returns a File formed from joining this File with ext. -#### func (File) LastModified - -```go -func (f File) LastModified() time.Time -``` -LastModified returns the time the file was last modified. - #### func (File) LookPath ```go @@ -244,20 +206,6 @@ func (fs FileSet) Filter(patterns ...string) FileSet Filter returns the list of files in this FileSet that matches any pattern in patterns. -#### func (FileSet) LastModified - -```go -func (fs FileSet) LastModified() time.Time -``` -LastModified returns the most recent time any of the files were modified. - -#### func (FileSet) Remove - -```go -func (fs FileSet) Remove(files ...File) FileSet -``` -Remove returns a new FileSet with files removed from this FileSet. - #### type Root ```go diff --git a/build/cpp/README.md b/build/cpp/README.md index d5c793ee3..263ca6036 100644 --- a/build/cpp/README.md +++ b/build/cpp/README.md @@ -12,40 +12,67 @@ const ( ) ``` -#### func Compile +#### func IntermediatePath ```go -func Compile(sources build.FileSet, cfg Config, env build.Environment) (build.FileSet, error) +func IntermediatePath(source build.File, ext string, cfg Config, env build.Environment) build.File ``` -Compile compiles the list of source files into object files using the Config and -build Environment. Compile returns the list of object files. +IntermediatePath returns a File in the intermediate directory for generating a +file built from source using cfg and env. -#### func DynamicLibrary +#### func MakeCompile ```go -func DynamicLibrary(inputs build.FileSet, cfg Config, env build.Environment) (build.File, error) +func MakeCompile(sources build.FileSet, cfg Config, env build.Environment) build.FileSet ``` -DynamicLibrary links the list of input files into an dynamically-linked library -using the Config and build Environment. The inputs can be a combination of -source files, object files and / or library files. DynamicLibrary returns the -output dynamic-library file file. +Add make steps to compile all the specified source files. Returns fileset of the +resulting object files. Note we do not get a dependency on the compiler. -#### func Executable +#### func MakeCopy ```go -func Executable(inputs build.FileSet, cfg Config, env build.Environment) (build.File, error) +func MakeCopy(src build.File, dest build.File, cfg Config, env build.Environment) ``` -Executable links the list of input files into an executable using the Config and -build Environment. The inputs can be a combination of source files, object files -and / or library files. Executable returns the output executable file. +Add a make step to copy a file from "src" to "dest". The copy only happens on +the host OS. -#### func IntermediatePath +#### func MakeDynamicLibrary ```go -func IntermediatePath(source build.File, ext string, cfg Config, env build.Environment) build.File +func MakeDynamicLibrary(inputs build.FileSet, cfg Config, env build.Environment) build.File ``` -IntermediatePath returns a File in the intermediate directory for generating a -file built from source using cfg and env. +Add make steps to construct a dynamic library. The inputs can be a combination +of source files, object files and / or library files. Source file inputs will +generate compilation steps. Returns the output library name. Note we do not get +a dependency on the linker. + +#### func MakeExecutable + +```go +func MakeExecutable(inputs build.FileSet, cfg Config, env build.Environment) build.File +``` +Add make steps to construct an executable. The inputs can be a combination of +source files, object files and / or library files. Source file inputs will +generate compilation steps. Returns the output library name. Note we do not get +a dependency on the linker. + +#### func MakeRunTest + +```go +func MakeRunTest(test build.File, cfg Config) +``` +Add a make step to run a test. The test only runs on the host OS. The test is +automatically included in the "test" target. + +#### func MakeStaticLibrary + +```go +func MakeStaticLibrary(inputs build.FileSet, cfg Config, env build.Environment) build.File +``` +Add make steps to construct a static library. The inputs may be a combination of +source and / or object files. Source file inputs will generate compilation +steps. Returns the output library name. Note we do not get a dependency on the +archiver. #### func ParseDepFile @@ -57,15 +84,6 @@ compiler. If parsing succeeds and all dependencies exist then ParseDepFile returns the list of file dependencies in deps and depsValid is true, otherwise depsValid is false. -#### func StaticLibrary - -```go -func StaticLibrary(inputs build.FileSet, cfg Config, env build.Environment) (build.File, error) -``` -StaticLibrary archives the list of input files into an static library using the -Config and build Environment. The inputs can be a combination of source files -and / or object files. StaticLibrary returns the output static library file. - #### func Triplet ```go diff --git a/builder/README.md b/builder/README.md index cfa2cfe34..28d9358c8 100644 --- a/builder/README.md +++ b/builder/README.md @@ -12,23 +12,55 @@ in the database, optionally depending on replay outputs. ```go func Captures(db database.Database, logger log.Logger) (service.CaptureIdArray, error) ``` -Captures returns all the captures stored by the database. +Captures returns all the captures stored by the database by identifier. #### func ImportCapture ```go -func ImportCapture(name string, atoms atom.List, db database.Database, logger log.Logger) (service.CaptureId, error) +func ImportCapture(name string, atoms atom.List, d database.Database, l log.Logger) (service.CaptureId, error) ``` ImportCapture builds a new capture containing atoms, stores it into db and returns the new capture identifier. -#### func New +#### type Context ```go -func New() *builder +type Context struct { + ReplayManager *replay.Manager +} +``` + +Context is the type that should be passed to the database constructor's +buildContext parameter. + +#### type ConvertImage + +```go +type ConvertImage struct { + binary.Generate + Data binary.ID + Width int + Height int + FormatFrom image.Format + FormatTo image.Format +} +``` + +ConvertImage is a request to decode a compressed texture. + +#### func (*ConvertImage) BuildLazy + +```go +func (r *ConvertImage) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *database.Blob holding the converted image for the +ConvertImage request. + +#### func (*ConvertImage) Class + +```go +func (*ConvertImage) Class() binary.Class ``` -New creates a database.builder which can hold a replayManager, potentially -required to build request outputs. #### type GetFramebufferColor @@ -46,6 +78,14 @@ type GetFramebufferColor struct { GetFramebufferColor records the parameters of a service.GetFramebufferColor RPC request. +#### func (*GetFramebufferColor) BuildLazy + +```go +func (r *GetFramebufferColor) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.ImageInfo resulting from the given +GetFramebufferColor request. + #### func (*GetFramebufferColor) Class ```go @@ -67,6 +107,14 @@ type GetFramebufferDepth struct { GetFramebufferDepth records the parameters of a service.GetFramebufferDepth RPC request. +#### func (*GetFramebufferDepth) BuildLazy + +```go +func (r *GetFramebufferDepth) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +Build returns the *service.ImageInfo resulting from the given +GetFramebufferDepth request. + #### func (*GetFramebufferDepth) Class ```go @@ -84,6 +132,14 @@ type GetHierarchy struct { GetHierarchy records the parameters of a service.GetHierarchy RPC request. +#### func (*GetHierarchy) BuildLazy + +```go +func (r *GetHierarchy) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.Hierarchy resulting from the given GetHierarchy +request. + #### func (*GetHierarchy) Class ```go @@ -103,6 +159,14 @@ type GetMemoryInfo struct { GetMemoryInfo records the parameters of a service.GetMemoryInfo RPC request. +#### func (*GetMemoryInfo) BuildLazy + +```go +func (r *GetMemoryInfo) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.MemoryInfo resulting from the given GetMemoryInfo +request. + #### func (*GetMemoryInfo) Class ```go @@ -121,6 +185,13 @@ type GetState struct { GetState records the parameters of a service.GetState RPC request. +#### func (*GetState) BuildLazy + +```go +func (r *GetState) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.Binary resulting from the given GetState request. + #### func (*GetState) Class ```go @@ -140,6 +211,14 @@ type GetTimingInfo struct { GetTimingInfo records the parameters of a service.GetTimingInfo RPC request. +#### func (*GetTimingInfo) BuildLazy + +```go +func (r *GetTimingInfo) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.TimingInfo resulting from the given GetTimingInfo +request. + #### func (*GetTimingInfo) Class ```go @@ -163,6 +242,14 @@ type PrerenderFramebuffers struct { PrerenderFramebuffers records the parameters of a service.PrerenderFramebuffers RPC request. +#### func (*PrerenderFramebuffers) BuildLazy + +```go +func (r *PrerenderFramebuffers) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy renders and caches all the framebuffer color buffers in the +GetFramebufferDepth request, returning an empty *service.Binary. + #### func (*PrerenderFramebuffers) Class ```go @@ -187,6 +274,14 @@ type RenderFramebufferColor struct { RenderFramebufferColor records the parameters of an internal RenderFramebufferColor request. +#### func (*RenderFramebufferColor) BuildLazy + +```go +func (r *RenderFramebufferColor) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.Binary data for the given RenderFramebufferColor +request. + #### func (*RenderFramebufferColor) Class ```go @@ -210,6 +305,14 @@ type RenderFramebufferDepth struct { RenderFramebufferDepth records the parameters of an internal RenderFramebufferDepth request. +#### func (*RenderFramebufferDepth) BuildLazy + +```go +func (r *RenderFramebufferDepth) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns the *service.Binary data for the given RenderFramebufferDepth +request. + #### func (*RenderFramebufferDepth) Class ```go @@ -230,6 +333,13 @@ type ReplaceAtom struct { ReplaceAtom records the parameters of a service.ReplaceAtom RPC request. +#### func (*ReplaceAtom) BuildLazy + +```go +func (request *ReplaceAtom) BuildLazy(c interface{}, d database.Database, l log.Logger) (binary.Object, error) +``` +BuildLazy returns a new *service.Capture, with a single atom replaced. + #### func (*ReplaceAtom) Class ```go diff --git a/cc/README.md b/cc/README.md index d36625e32..20efbaefe 100644 --- a/cc/README.md +++ b/cc/README.md @@ -1,2 +1,58 @@ # cc -- + import "android.googlesource.com/platform/tools/gpu/cc" + + +## Usage + +```go +var ( + ExternalRoot = build.RepoRoot.Path.Join("external") + GPURoot = build.RepoRoot.Path.Join("tools", "gpu", "src", "android.googlesource.com", "platform", "tools", "gpu") + BinRoot = build.RepoRoot.Path.Join("tools", "gpu", "bin") + CCRoot = GPURoot.Join("cc") + GapicRoot = CCRoot.Join("gapic") + GapiiRoot = CCRoot.Join("gapii") + GapirRoot = CCRoot.Join("gapir") + ReplaydRoot = CCRoot.Join("replayd") + GmockRoot = ExternalRoot.Join("gmock") + GtestRoot = ExternalRoot.Join("gtest") +) +``` + +#### func Graph + +```go +func Graph(targetNames []string) +``` +Generate "maker" graph for building the cpp code. + +#### type Target + +```go +type Target struct { + SourceFiles []string + Gtest cpp.Config + Gmock cpp.Config + Gapic cpp.Config + GapicTests cpp.Config + Gapii cpp.Config + Gapir cpp.Config + GapirTests cpp.Config + Spy cpp.Config + Replayd cpp.Config +} +``` + + +#### func (Target) Build + +```go +func (t Target) Build(env build.Environment) +``` + +#### func (Target) Extend + +```go +func (t Target) Extend(n Target) Target +``` diff --git a/config/README.md b/config/README.md index 1e510e448..d3d2f18f8 100644 --- a/config/README.md +++ b/config/README.md @@ -10,8 +10,9 @@ Package config contains a list of build configuration flags. const ( DebugAtom = false DebugDatabase = false - DebugDatabaseStores = false + DebugDatabaseVerify = false DebugReplay = false DebugReplayBuilder = false + DebugRPCCalls = false ) ``` diff --git a/database/README.md b/database/README.md index 129cd1bc3..d75f3d7d2 100644 --- a/database/README.md +++ b/database/README.md @@ -6,30 +6,105 @@ Package database implements the persistence layer for the gpu debugger tools. ## Usage +#### func Hash + +```go +func Hash(o binary.Object) (binary.ID, error) +``` +Hash returns a unique binary.ID based on the contents of the object. Two objects +of identical content will return the same ID, and the probability of two objects +with different content generating the same ID will be ignorable. Objects with a +graph structure are allowed. Only members that would be encoded using a +binary.Encoder are considered. + +#### func LazyOutputID + +```go +func LazyOutputID(in binary.ID) binary.ID +``` +LazyOutputID returns the identifier of a LazyOutput object given the identifier +of the Lazy. The database will not contain the LazyObject with the returned +identifier until it is built. + +#### func ResolveBlob + +```go +func ResolveBlob(id binary.ID, d Database, l log.Logger) ([]byte, error) +``` +Resolve blob loads a Blob from the database, returning the byte slice. + +#### func Store + +```go +func Store(obj binary.Object, d Database, l log.Logger) (binary.ID, error) +``` +Store is a helper that stores an object to the database with the id calculated +by the Hash function. + +#### func StoreBlob + +```go +func StoreBlob(data []byte, d Database, l log.Logger) (binary.ID, error) +``` +StoreBlob stores the byte slice data inside a Blob to the database d. + +#### type Blob + +```go +type Blob struct { + binary.Generate + Data []byte +} +``` + +Blob is an encodable wrapper for a byte array, used for storing raw data in +databases. + +#### func (*Blob) Class + +```go +func (*Blob) Class() binary.Class +``` + #### type Database ```go type Database interface { - StoreLink(to, id binary.ID, logger log.Logger) error - StoreRequest(request binary.Object, logger log.Logger) (id binary.ID, err error) - Store(binary.Object, log.Logger) (binary.ID, error) - Load(binary.ID, log.Logger, binary.Object) error + // Store adds a key value pair to the database. + // It is an error if the id is already mapped to an object. + Store(binary.ID, binary.Object, log.Logger) error + // Resolve attempts to resolve the final value associated with an id. + // It will traverse all Lazy objects, blocking until they are ready. + Resolve(binary.ID, log.Logger) (binary.Object, error) + // Containts returns true if the database has an entry for the specified id. Contains(binary.ID, log.Logger) bool - Close() } ``` Database is the interface to a resource store. -#### func Create +#### func NewInMemory ```go -func Create(path string, maxDataCacheSize, metaDataCompactionSize, maxDerivedCacheSize int, builder builder) Database +func NewInMemory(buildContext interface{}) Database ``` -Create builds a new database. +NewInMemory builds a new in memory database. -#### func CreateTransientDatabase +#### type Lazy ```go -func CreateTransientDatabase(inner Database) Database +type Lazy interface { + binary.Object + + // BuildLazy constructs and returns the lazily-built object. + // c is the build context that was passed to the database constructor. + BuildLazy(c interface{}, d Database, l log.Logger) (binary.Object, error) +} ``` + +Lazy is the interface for types that redirects database resolves to an object +lazily built using BuildLazy(). The BuildLazy() method will be called the first +time the object is resolved, and all subsequent resolves will return the same +pre-built object. Lazy is commonly implemented by objects that generate data +that is expensive to calculate but can be deterministically produced using the +information stored in the Lazy. diff --git a/gfxapi/README.md b/gfxapi/README.md index 3529d0867..7bd2ad5a3 100644 --- a/gfxapi/README.md +++ b/gfxapi/README.md @@ -4,19 +4,6 @@ Package gfxapi exposes the shared behavior of all graphics api's. -Copyright (C) 2015 The Android Open Source Project - -Licensed under the Apache License, Version 2.0 (the "License"); you may not use -this file except in compliance with the License. You may obtain a copy of the -License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software distributed -under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR -CONDITIONS OF ANY KIND, either express or implied. See the License for the -specific language governing permissions and limitations under the License. - ## Usage #### func Register @@ -68,6 +55,18 @@ const ( ) ``` +#### func (*FramebufferAttachment) Parse + +```go +func (v *FramebufferAttachment) Parse(s string) error +``` + +#### func (FramebufferAttachment) String + +```go +func (v FramebufferAttachment) String() string +``` + #### type ID ```go @@ -89,8 +88,15 @@ Valid returns true if the id is not the default zero value. type State struct { binary.Object + // Architecture holds information about the device architecture that was used + // to create the capture. + Architecture device.Architecture + // Memory holds the memory state of the application. - Memory memory.Memory + Memory map[memory.PoolID]*memory.Pool + + // NextPoolID hold the identifier of the next Pool to be created. + NextPoolID memory.PoolID // APIs holds the per-API context states. APIs map[API]interface{} @@ -98,3 +104,31 @@ type State struct { ``` State represents the graphics state across all contexts. + +#### func NewState + +```go +func NewState() *State +``` + +#### func (State) MemoryDecoder + +```go +func (st State) MemoryDecoder(s memory.Slice, d database.Database, l log.Logger) binary.Decoder +``` +MemoryDecoder returns a flat decoder backed by an endian reader that uses the +byte-order of the capture device to decode from the slice s. + +#### func (State) MemoryEncoder + +```go +func (st State) MemoryEncoder(p *memory.Pool, rng memory.Range) binary.Encoder +``` +MemoryEncoder returns a flat encoder backed by an endian reader that uses the +byte-order of the capture device to encode to the pool p, for the range rng. + +#### func (State) String + +```go +func (s State) String() string +``` diff --git a/gfxapi/gles/README.md b/gfxapi/gles/README.md index 2f6d3d281..a39801910 100644 --- a/gfxapi/gles/README.md +++ b/gfxapi/gles/README.md @@ -142,6 +142,62 @@ const ( ```go const ( + CompressedTexelFormat_EXT_texture_compression_dxt1_GL_COMPRESSED_RGB_S3TC_DXT1_EXT = CompressedTexelFormat_EXT_texture_compression_dxt1(33776) + CompressedTexelFormat_EXT_texture_compression_dxt1_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = CompressedTexelFormat_EXT_texture_compression_dxt1(33777) +) +``` + +```go +const ( + CompressedTexelFormat_EXT_texture_compression_s3tc_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = CompressedTexelFormat_EXT_texture_compression_s3tc(33778) + CompressedTexelFormat_EXT_texture_compression_s3tc_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = CompressedTexelFormat_EXT_texture_compression_s3tc(33779) +) +``` + +```go +const ( + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_4x4_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37808) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_5x4_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37809) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_5x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37810) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_6x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37811) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_6x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37812) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_8x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37813) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_8x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37814) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_8x8_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37815) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_10x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37816) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_10x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37817) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_10x8_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37818) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_10x10_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37819) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_12x10_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37820) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_RGBA_ASTC_12x12_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37821) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37840) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37841) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37842) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37843) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37844) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37845) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37846) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37847) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37848) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37849) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37850) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37851) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37852) + CompressedTexelFormat_KHR_texture_compression_astc_ldr_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = CompressedTexelFormat_KHR_texture_compression_astc_ldr(37853) +) +``` + +```go +const ( + CompressedTexelFormat_NV_texture_compression_latc_GL_COMPRESSED_LUMINANCE_LATC1_NV = CompressedTexelFormat_NV_texture_compression_latc(35952) + CompressedTexelFormat_NV_texture_compression_latc_GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_NV = CompressedTexelFormat_NV_texture_compression_latc(35953) + CompressedTexelFormat_NV_texture_compression_latc_GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_NV = CompressedTexelFormat_NV_texture_compression_latc(35954) + CompressedTexelFormat_NV_texture_compression_latc_GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_NV = CompressedTexelFormat_NV_texture_compression_latc(35955) +) +``` + +```go +const ( CompressedTexelFormat_GL_ATC_RGB_AMD = CompressedTexelFormat(35986) CompressedTexelFormat_GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = CompressedTexelFormat(35987) CompressedTexelFormat_GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = CompressedTexelFormat(34798) @@ -151,6 +207,66 @@ CompressedTexelFormat_AMD_compressed_ATC_texture ```go const ( + CompressedTexelFormat_GL_COMPRESSED_RGB_S3TC_DXT1_EXT = CompressedTexelFormat(33776) + CompressedTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = CompressedTexelFormat(33777) +) +``` +CompressedTexelFormat_EXT_texture_compression_dxt1 + +```go +const ( + CompressedTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = CompressedTexelFormat(33778) + CompressedTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = CompressedTexelFormat(33779) +) +``` +CompressedTexelFormat_EXT_texture_compression_s3tc + +```go +const ( + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_4x4_KHR = CompressedTexelFormat(37808) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_5x4_KHR = CompressedTexelFormat(37809) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_5x5_KHR = CompressedTexelFormat(37810) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_6x5_KHR = CompressedTexelFormat(37811) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_6x6_KHR = CompressedTexelFormat(37812) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x5_KHR = CompressedTexelFormat(37813) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x6_KHR = CompressedTexelFormat(37814) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x8_KHR = CompressedTexelFormat(37815) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x5_KHR = CompressedTexelFormat(37816) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x6_KHR = CompressedTexelFormat(37817) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x8_KHR = CompressedTexelFormat(37818) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x10_KHR = CompressedTexelFormat(37819) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_12x10_KHR = CompressedTexelFormat(37820) + CompressedTexelFormat_GL_COMPRESSED_RGBA_ASTC_12x12_KHR = CompressedTexelFormat(37821) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = CompressedTexelFormat(37840) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = CompressedTexelFormat(37841) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = CompressedTexelFormat(37842) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = CompressedTexelFormat(37843) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = CompressedTexelFormat(37844) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = CompressedTexelFormat(37845) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = CompressedTexelFormat(37846) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = CompressedTexelFormat(37847) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = CompressedTexelFormat(37848) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = CompressedTexelFormat(37849) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = CompressedTexelFormat(37850) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = CompressedTexelFormat(37851) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = CompressedTexelFormat(37852) + CompressedTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = CompressedTexelFormat(37853) +) +``` +CompressedTexelFormat_KHR_texture_compression_astc_ldr + +```go +const ( + CompressedTexelFormat_GL_COMPRESSED_LUMINANCE_LATC1_NV = CompressedTexelFormat(35952) + CompressedTexelFormat_GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_NV = CompressedTexelFormat(35953) + CompressedTexelFormat_GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_NV = CompressedTexelFormat(35954) + CompressedTexelFormat_GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_NV = CompressedTexelFormat(35955) +) +``` +CompressedTexelFormat_NV_texture_compression_latc + +```go +const ( ImageTexelFormat_GL_LUMINANCE = ImageTexelFormat(6409) ImageTexelFormat_GL_LUMINANCE_ALPHA = ImageTexelFormat(6410) ) @@ -193,6 +309,66 @@ CompressedTexelFormat_AMD_compressed_ATC_texture ```go const ( + ImageTexelFormat_GL_COMPRESSED_RGB_S3TC_DXT1_EXT = ImageTexelFormat(33776) + ImageTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = ImageTexelFormat(33777) +) +``` +CompressedTexelFormat_EXT_texture_compression_dxt1 + +```go +const ( + ImageTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = ImageTexelFormat(33778) + ImageTexelFormat_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = ImageTexelFormat(33779) +) +``` +CompressedTexelFormat_EXT_texture_compression_s3tc + +```go +const ( + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_4x4_KHR = ImageTexelFormat(37808) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_5x4_KHR = ImageTexelFormat(37809) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_5x5_KHR = ImageTexelFormat(37810) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_6x5_KHR = ImageTexelFormat(37811) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_6x6_KHR = ImageTexelFormat(37812) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x5_KHR = ImageTexelFormat(37813) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x6_KHR = ImageTexelFormat(37814) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_8x8_KHR = ImageTexelFormat(37815) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x5_KHR = ImageTexelFormat(37816) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x6_KHR = ImageTexelFormat(37817) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x8_KHR = ImageTexelFormat(37818) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_10x10_KHR = ImageTexelFormat(37819) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_12x10_KHR = ImageTexelFormat(37820) + ImageTexelFormat_GL_COMPRESSED_RGBA_ASTC_12x12_KHR = ImageTexelFormat(37821) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = ImageTexelFormat(37840) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = ImageTexelFormat(37841) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = ImageTexelFormat(37842) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = ImageTexelFormat(37843) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = ImageTexelFormat(37844) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = ImageTexelFormat(37845) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = ImageTexelFormat(37846) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = ImageTexelFormat(37847) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = ImageTexelFormat(37848) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = ImageTexelFormat(37849) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = ImageTexelFormat(37850) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = ImageTexelFormat(37851) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = ImageTexelFormat(37852) + ImageTexelFormat_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = ImageTexelFormat(37853) +) +``` +CompressedTexelFormat_KHR_texture_compression_astc_ldr + +```go +const ( + ImageTexelFormat_GL_COMPRESSED_LUMINANCE_LATC1_NV = ImageTexelFormat(35952) + ImageTexelFormat_GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_NV = ImageTexelFormat(35953) + ImageTexelFormat_GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_NV = ImageTexelFormat(35954) + ImageTexelFormat_GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_NV = ImageTexelFormat(35955) +) +``` +CompressedTexelFormat_NV_texture_compression_latc + +```go +const ( TexelType_GL_UNSIGNED_BYTE = TexelType(5121) TexelType_GL_UNSIGNED_SHORT = TexelType(5123) TexelType_GL_UNSIGNED_INT = TexelType(5125) @@ -901,6 +1077,26 @@ QueryTarget_EXT_disjoint_timer_query ```go const ( + UniformBlockParameter_GL_UNIFORM_BLOCK_BINDING = UniformBlockParameter(35391) + UniformBlockParameter_GL_UNIFORM_BLOCK_DATA_SIZE = UniformBlockParameter(35392) + UniformBlockParameter_GL_UNIFORM_BLOCK_NAME_LENGTH = UniformBlockParameter(35393) + UniformBlockParameter_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = UniformBlockParameter(35394) + UniformBlockParameter_GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = UniformBlockParameter(35395) + UniformBlockParameter_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = UniformBlockParameter(35396) + UniformBlockParameter_GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = UniformBlockParameter(35397) + UniformBlockParameter_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = UniformBlockParameter(35398) +) +``` + +```go +const ( + IndexedBufferTarget_GL_TRANSFORM_FEEDBACK_BUFFER = IndexedBufferTarget(35982) + IndexedBufferTarget_GL_UNIFORM_BUFFER = IndexedBufferTarget(35345) +) +``` + +```go +const ( TilePreserveMaskQCOM_GL_COLOR_BUFFER_BIT0_QCOM = TilePreserveMaskQCOM(1) TilePreserveMaskQCOM_GL_COLOR_BUFFER_BIT1_QCOM = TilePreserveMaskQCOM(2) TilePreserveMaskQCOM_GL_COLOR_BUFFER_BIT2_QCOM = TilePreserveMaskQCOM(4) @@ -957,6 +1153,15 @@ const ( ```go const ( + ClientWaitSyncSignal_GL_ALREADY_SIGNALED = ClientWaitSyncSignal(37146) + ClientWaitSyncSignal_GL_TIMEOUT_EXPIRED = ClientWaitSyncSignal(37147) + ClientWaitSyncSignal_GL_CONDITION_SATISFIED = ClientWaitSyncSignal(37148) + ClientWaitSyncSignal_GL_WAIT_FAILED = ClientWaitSyncSignal(37149) +) +``` + +```go +const ( ArrayType_GL_POINT_SIZE_ARRAY_OES = ArrayType(35740) ) ``` @@ -1119,6 +1324,18 @@ StateVariable_GLES_3_1 ```go const ( + SyncCondition_GL_SYNC_GPU_COMMANDS_COMPLETE = SyncCondition(37143) +) +``` + +```go +const ( + SyncFlags_GL_SYNC_FLUSH_COMMANDS_BIT = SyncFlags(1) +) +``` + +```go +const ( Texture2DImageTarget_GL_TEXTURE_2D = Texture2DImageTarget(3553) ) ``` @@ -1184,7 +1401,7 @@ const ( ```go const ( - Type_ARB_half_float_vertex_GL_ARB_half_float_vertex = Type_ARB_half_float_vertex(5131) + Type_ARB_half_float_vertex_GL_HALF_FLOAT_ARB = Type_ARB_half_float_vertex(5131) ) ``` @@ -1196,7 +1413,7 @@ const ( ```go const ( - VertexAttribType_GL_ARB_half_float_vertex = VertexAttribType(5131) + VertexAttribType_GL_HALF_FLOAT_ARB = VertexAttribType(5131) ) ``` Type_ARB_half_float_vertex @@ -1214,6 +1431,97 @@ Type_OES_vertex_half_float func API() gfxapi.API ``` +#### func NewProgram + +```go +func NewProgram(a device.Architecture, d database.Database, l log.Logger, + vertexShaderID, fragmentShaderID ShaderId, programID ProgramId, + vertexShaderSource, fragmentShaderSource string) []atom.Atom +``` +NewProgram returns the atoms to create a shader program with compiled vertex and +fragment shaders. The returned program is not linked. + +#### type Architecture + +```go +type Architecture struct { + binary.Generate + + PointerAlignment uint32 + PointerSize uint32 + IntegerSize uint32 + LittleEndian bool +} +``` + +////////////////////////////////////////////////////////////////////////////// +Architecture +////////////////////////////////////////////////////////////////////////////// + +#### func NewArchitecture + +```go +func NewArchitecture(Pointer_alignment uint32, Pointer_size uint32, Integer_size uint32, Little_endian bool) *Architecture +``` + +#### func (*Architecture) API + +```go +func (c *Architecture) API() gfxapi.API +``` + +#### func (*Architecture) AddRead + +```go +func (a *Architecture) AddRead(rng memory.Range, id binary.ID) *Architecture +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The Architecture pointer is returned so that calls can be chained. + +#### func (*Architecture) AddWrite + +```go +func (a *Architecture) AddWrite(rng memory.Range, id binary.ID) *Architecture +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The Architecture pointer is returned so that calls can be chained. + +#### func (*Architecture) Class + +```go +func (*Architecture) Class() binary.Class +``` + +#### func (*Architecture) Flags + +```go +func (c *Architecture) Flags() atom.Flags +``` + +#### func (*Architecture) Mutate + +```go +func (ϟa *Architecture) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*Architecture) Observations + +```go +func (a *Architecture) Observations() *atom.Observations +``` + +#### func (*Architecture) String + +```go +func (a *Architecture) String() string +``` + +#### func (*Architecture) TypeID + +```go +func (c *Architecture) TypeID() atom.TypeID +``` + #### type ArrayType ```go @@ -1224,6 +1532,12 @@ type ArrayType uint32 enum ArrayType ////////////////////////////////////////////////////////////////////////////// +#### func (*ArrayType) Parse + +```go +func (v *ArrayType) Parse(s string) error +``` + #### func (ArrayType) String ```go @@ -1240,6 +1554,12 @@ type ArrayType_GLES_1_1 uint32 enum ArrayType_GLES_1_1 ////////////////////////////////////////////////////////////////////////////// +#### func (*ArrayType_GLES_1_1) Parse + +```go +func (v *ArrayType_GLES_1_1) Parse(s string) error +``` + #### func (ArrayType_GLES_1_1) String ```go @@ -1256,60 +1576,54 @@ type ArrayType_OES_point_size_array uint32 enum ArrayType_OES_point_size_array ////////////////////////////////////////////////////////////////////////////// -#### func (ArrayType_OES_point_size_array) String +#### func (*ArrayType_OES_point_size_array) Parse ```go -func (v ArrayType_OES_point_size_array) String() string +func (v *ArrayType_OES_point_size_array) Parse(s string) error ``` -#### type AttributeLocation +#### func (ArrayType_OES_point_size_array) String ```go -type AttributeLocation uint32 +func (v ArrayType_OES_point_size_array) String() string ``` - -#### func (*AttributeLocation) Equal +#### type AttributeLocation ```go -func (c *AttributeLocation) Equal(rhs AttributeLocation) bool +type AttributeLocation int32 ``` -#### func (*AttributeLocation) Less -```go -func (c *AttributeLocation) Less(rhs AttributeLocation) bool -``` - -#### type AttributeLocation_CharBufferMap +#### type AttributeLocationːVertexAttributeArrayʳᵐ ```go -type AttributeLocation_CharBufferMap map[string]AttributeLocation +type AttributeLocationːVertexAttributeArrayʳᵐ map[AttributeLocation](*VertexAttributeArray) ``` -#### func (AttributeLocation_CharBufferMap) Contains +#### func (AttributeLocationːVertexAttributeArrayʳᵐ) Contains ```go -func (m AttributeLocation_CharBufferMap) Contains(key string) bool +func (m AttributeLocationːVertexAttributeArrayʳᵐ) Contains(key AttributeLocation) bool ``` -#### func (AttributeLocation_CharBufferMap) Delete +#### func (AttributeLocationːVertexAttributeArrayʳᵐ) Delete ```go -func (m AttributeLocation_CharBufferMap) Delete(key string) +func (m AttributeLocationːVertexAttributeArrayʳᵐ) Delete(key AttributeLocation) ``` -#### func (AttributeLocation_CharBufferMap) Get +#### func (AttributeLocationːVertexAttributeArrayʳᵐ) Get ```go -func (m AttributeLocation_CharBufferMap) Get(key string) AttributeLocation +func (m AttributeLocationːVertexAttributeArrayʳᵐ) Get(key AttributeLocation) *VertexAttributeArray ``` -#### func (AttributeLocation_CharBufferMap) Range +#### func (AttributeLocationːVertexAttributeArrayʳᵐ) Range ```go -func (m AttributeLocation_CharBufferMap) Range() []AttributeLocation +func (m AttributeLocationːVertexAttributeArrayʳᵐ) Range() [](*VertexAttributeArray) ``` #### type BOOL @@ -1319,23 +1633,12 @@ type BOOL int64 ``` -#### func (*BOOL) Equal - -```go -func (c *BOOL) Equal(rhs BOOL) bool -``` - -#### func (*BOOL) Less - -```go -func (c *BOOL) Less(rhs BOOL) bool -``` - #### type BackbufferInfo ```go type BackbufferInfo struct { binary.Generate + Width int32 Height int32 ColorFmt RenderbufferFormat @@ -1352,14 +1655,7 @@ BackbufferInfo #### func NewBackbufferInfo ```go -func NewBackbufferInfo( - pWidth int32, - pHeight int32, - pColorFmt RenderbufferFormat, - pDepthFmt RenderbufferFormat, - pStencilFmt RenderbufferFormat, - pResetViewportScissor bool, -) *BackbufferInfo +func NewBackbufferInfo(Width int32, Height int32, Color_fmt RenderbufferFormat, Depth_fmt RenderbufferFormat, Stencil_fmt RenderbufferFormat, ResetViewportScissor bool) *BackbufferInfo ``` #### func (*BackbufferInfo) API @@ -1368,6 +1664,22 @@ func NewBackbufferInfo( func (c *BackbufferInfo) API() gfxapi.API ``` +#### func (*BackbufferInfo) AddRead + +```go +func (a *BackbufferInfo) AddRead(rng memory.Range, id binary.ID) *BackbufferInfo +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The BackbufferInfo pointer is returned so that calls can be chained. + +#### func (*BackbufferInfo) AddWrite + +```go +func (a *BackbufferInfo) AddWrite(rng memory.Range, id binary.ID) *BackbufferInfo +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The BackbufferInfo pointer is returned so that calls can be chained. + #### func (*BackbufferInfo) Class ```go @@ -1383,19 +1695,25 @@ func (c *BackbufferInfo) Flags() atom.Flags #### func (*BackbufferInfo) Mutate ```go -func (ϟa *BackbufferInfo) Mutate(ϟs *gfxapi.State) error +func (ϟa *BackbufferInfo) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*BackbufferInfo) Observations + +```go +func (a *BackbufferInfo) Observations() *atom.Observations ``` #### func (*BackbufferInfo) Replay ```go -func (ϟa *BackbufferInfo) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *BackbufferInfo) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*BackbufferInfo) String ```go -func (c *BackbufferInfo) String() string +func (a *BackbufferInfo) String() string ``` #### func (*BackbufferInfo) TypeID @@ -1414,6 +1732,12 @@ type BaseTexelFormat uint32 enum BaseTexelFormat ////////////////////////////////////////////////////////////////////////////// +#### func (*BaseTexelFormat) Parse + +```go +func (v *BaseTexelFormat) Parse(s string) error +``` + #### func (BaseTexelFormat) String ```go @@ -1430,6 +1754,12 @@ type BlendEquation uint32 enum BlendEquation ////////////////////////////////////////////////////////////////////////////// +#### func (*BlendEquation) Parse + +```go +func (v *BlendEquation) Parse(s string) error +``` + #### func (BlendEquation) String ```go @@ -1446,6 +1776,12 @@ type BlendFactor uint32 enum BlendFactor ////////////////////////////////////////////////////////////////////////////// +#### func (*BlendFactor) Parse + +```go +func (v *BlendFactor) Parse(s string) error +``` + #### func (BlendFactor) String ```go @@ -1490,55 +1826,192 @@ func (c *BlendState) GetCreatedAt() atom.ID func (c *BlendState) Init() ``` -#### type BoolArray +#### type Bool + +```go +type Bool int64 +``` + + +#### type Boolˢ + +```go +type Boolˢ struct { + binary.Generate + SliceInfo +} +``` + +Boolˢ is a slice of bool. + +#### func AsBoolˢ + +```go +func AsBoolˢ(s Slice, ϟs *gfxapi.State) Boolˢ +``` +AsBoolˢ returns s cast to a Boolˢ. The returned slice length will be calculated +so that the returned slice is no longer (in bytes) than s. + +#### func MakeBoolˢ + +```go +func MakeBoolˢ(count uint64, ϟs *gfxapi.State) Boolˢ +``` +MakeBoolˢ returns a Boolˢ backed by a new memory pool. + +#### func (*Boolˢ) Class + +```go +func (*Boolˢ) Class() binary.Class +``` + +#### func (Boolˢ) Clone + +```go +func (s Boolˢ) Clone(ϟs *gfxapi.State) Boolˢ +``` +Clone returns a copy of the Boolˢ in a new memory pool. + +#### func (Boolˢ) Copy ```go -type BoolArray []bool +func (dst Boolˢ) Copy(src Boolˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Boolˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Boolˢ) Decoder +```go +func (s Boolˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. -#### func (BoolArray) Len +#### func (Boolˢ) ElementSize ```go -func (s BoolArray) Len() int +func (s Boolˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Boolˢ points to. -#### func (BoolArray) Range +#### func (Boolˢ) Encoder ```go -func (s BoolArray) Range() []bool +func (s Boolˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### type Bool_CapabilityMap +#### func (Boolˢ) Index ```go -type Bool_CapabilityMap map[Capability]bool +func (s Boolˢ) Index(i uint64, ϟs *gfxapi.State) Boolᵖ ``` +Index returns a Boolᵖ to the i'th element in this Boolˢ. +#### func (Boolˢ) Range -#### func (Bool_CapabilityMap) Contains +```go +func (s Boolˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Boolˢ) Read ```go -func (m Bool_CapabilityMap) Contains(key Capability) bool +func (s Boolˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []bool ``` +Read reads and returns all the bool elements in this Boolˢ. -#### func (Bool_CapabilityMap) Delete +#### func (Boolˢ) ResourceID ```go -func (m Bool_CapabilityMap) Delete(key Capability) +func (s Boolˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### func (Bool_CapabilityMap) Get +#### func (Boolˢ) Slice ```go -func (m Bool_CapabilityMap) Get(key Capability) bool +func (s Boolˢ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ ``` +Slice returns a sub-slice from the Boolˢ using start and end indices. -#### func (Bool_CapabilityMap) Range +#### func (Boolˢ) String ```go -func (m Bool_CapabilityMap) Range() []bool +func (s Boolˢ) String() string ``` +String returns a string description of the Boolˢ slice. + +#### func (Boolˢ) Write + +```go +func (dst Boolˢ) Write(src []bool, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Boolᵖ + +```go +type Boolᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Boolᵖ is a pointer to a bool element. + +#### func NewBoolᵖ + +```go +func NewBoolᵖ(addr memory.Pointer) Boolᵖ +``` +NewBoolᵖ returns a Boolᵖ that points to addr in the application pool. + +#### func (*Boolᵖ) Class + +```go +func (*Boolᵖ) Class() binary.Class +``` + +#### func (Boolᵖ) ElementSize + +```go +func (p Boolᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Boolᵖ points to. + +#### func (Boolᵖ) Read + +```go +func (p Boolᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) bool +``` +Read reads and returns the bool element at the pointer. + +#### func (Boolᵖ) Slice + +```go +func (p Boolᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ +``` +Slice returns a new Boolˢ from the pointer using start and end indices. + +#### func (Boolᵖ) String + +```go +func (p Boolᵖ) String() string +``` +String returns a string description of the Boolᵖ pointer. + +#### func (Boolᵖ) Write + +```go +func (p Boolᵖ) Write(value bool, ϟs *gfxapi.State) +``` +Write writes value to the bool element at the pointer. #### type Buffer @@ -1546,7 +2019,7 @@ func (m Bool_CapabilityMap) Range() []bool type Buffer struct { binary.Generate CreatedAt atom.ID - Data memory.Memory + Data U8ˢ Size int32 Usage BufferUsage } @@ -1574,43 +2047,53 @@ func (c *Buffer) GetCreatedAt() atom.ID func (c *Buffer) Init() ``` -#### type BufferArray +#### type BufferDataPointer ```go -type BufferArray []Buffer +type BufferDataPointer struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +BufferDataPointer is a pointer to a void element. -#### func (BufferArray) Len +#### func NewBufferDataPointer ```go -func (s BufferArray) Len() int +func NewBufferDataPointer(addr memory.Pointer) BufferDataPointer ``` +NewBufferDataPointer returns a BufferDataPointer that points to addr in the +application pool. -#### func (BufferArray) Range +#### func (*BufferDataPointer) Class ```go -func (s BufferArray) Range() []Buffer +func (*BufferDataPointer) Class() binary.Class ``` -#### type BufferDataPointer +#### func (BufferDataPointer) ElementSize ```go -type BufferDataPointer memory.Pointer +func (p BufferDataPointer) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that BufferDataPointer +points to. - -#### func (*BufferDataPointer) Equal +#### func (BufferDataPointer) Slice ```go -func (c *BufferDataPointer) Equal(rhs BufferDataPointer) bool +func (p BufferDataPointer) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (*BufferDataPointer) Less +#### func (BufferDataPointer) String ```go -func (c *BufferDataPointer) Less(rhs BufferDataPointer) bool +func (p BufferDataPointer) String() string ``` +String returns a string description of the BufferDataPointer pointer. #### type BufferId @@ -1619,113 +2102,237 @@ type BufferId uint32 ``` -#### func (*BufferId) Equal +#### type BufferIdːBufferʳᵐ + +```go +type BufferIdːBufferʳᵐ map[BufferId](*Buffer) +``` + + +#### func (BufferIdːBufferʳᵐ) Contains + +```go +func (m BufferIdːBufferʳᵐ) Contains(key BufferId) bool +``` + +#### func (BufferIdːBufferʳᵐ) Delete + +```go +func (m BufferIdːBufferʳᵐ) Delete(key BufferId) +``` + +#### func (BufferIdːBufferʳᵐ) Get ```go -func (c *BufferId) Equal(rhs BufferId) bool +func (m BufferIdːBufferʳᵐ) Get(key BufferId) *Buffer ``` -#### func (*BufferId) Less +#### func (BufferIdːBufferʳᵐ) Range ```go -func (c *BufferId) Less(rhs BufferId) bool +func (m BufferIdːBufferʳᵐ) Range() [](*Buffer) ``` -#### type BufferIdArray +#### type BufferIdˢ ```go -type BufferIdArray []BufferId +type BufferIdˢ struct { + binary.Generate + SliceInfo +} ``` +BufferIdˢ is a slice of BufferId. -#### func (BufferIdArray) Len +#### func AsBufferIdˢ ```go -func (s BufferIdArray) Len() int +func AsBufferIdˢ(s Slice, ϟs *gfxapi.State) BufferIdˢ ``` +AsBufferIdˢ returns s cast to a BufferIdˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### func (BufferIdArray) Range +#### func MakeBufferIdˢ ```go -func (s BufferIdArray) Range() []BufferId +func MakeBufferIdˢ(count uint64, ϟs *gfxapi.State) BufferIdˢ ``` +MakeBufferIdˢ returns a BufferIdˢ backed by a new memory pool. -#### type BufferId_BufferTargetMap +#### func (*BufferIdˢ) Class ```go -type BufferId_BufferTargetMap map[BufferTarget]BufferId +func (*BufferIdˢ) Class() binary.Class ``` +#### func (BufferIdˢ) Clone + +```go +func (s BufferIdˢ) Clone(ϟs *gfxapi.State) BufferIdˢ +``` +Clone returns a copy of the BufferIdˢ in a new memory pool. -#### func (BufferId_BufferTargetMap) Contains +#### func (BufferIdˢ) Copy ```go -func (m BufferId_BufferTargetMap) Contains(key BufferTarget) bool +func (dst BufferIdˢ) Copy(src BufferIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s BufferIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (BufferId_BufferTargetMap) Delete +#### func (BufferIdˢ) Decoder ```go -func (m BufferId_BufferTargetMap) Delete(key BufferTarget) +func (s BufferIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (BufferId_BufferTargetMap) Get +#### func (BufferIdˢ) ElementSize ```go -func (m BufferId_BufferTargetMap) Get(key BufferTarget) BufferId +func (s BufferIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that BufferIdˢ points to. -#### func (BufferId_BufferTargetMap) Range +#### func (BufferIdˢ) Encoder ```go -func (m BufferId_BufferTargetMap) Range() []BufferId +func (s BufferIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### type BufferParameter +#### func (BufferIdˢ) Index ```go -type BufferParameter uint32 +func (s BufferIdˢ) Index(i uint64, ϟs *gfxapi.State) BufferIdᵖ ``` +Index returns a BufferIdᵖ to the i'th element in this BufferIdˢ. -////////////////////////////////////////////////////////////////////////////// -enum BufferParameter -////////////////////////////////////////////////////////////////////////////// +#### func (BufferIdˢ) Range -#### func (BufferParameter) String +```go +func (s BufferIdˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (BufferIdˢ) Read ```go -func (v BufferParameter) String() string +func (s BufferIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []BufferId ``` +Read reads and returns all the BufferId elements in this BufferIdˢ. -#### type BufferPtr_BufferIdMap +#### func (BufferIdˢ) ResourceID ```go -type BufferPtr_BufferIdMap map[BufferId]*Buffer +func (s BufferIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (BufferIdˢ) Slice +```go +func (s BufferIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) BufferIdˢ +``` +Slice returns a sub-slice from the BufferIdˢ using start and end indices. -#### func (BufferPtr_BufferIdMap) Contains +#### func (BufferIdˢ) String ```go -func (m BufferPtr_BufferIdMap) Contains(key BufferId) bool +func (s BufferIdˢ) String() string ``` +String returns a string description of the BufferIdˢ slice. -#### func (BufferPtr_BufferIdMap) Delete +#### func (BufferIdˢ) Write ```go -func (m BufferPtr_BufferIdMap) Delete(key BufferId) +func (dst BufferIdˢ) Write(src []BufferId, ϟs *gfxapi.State) uint64 ``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### func (BufferPtr_BufferIdMap) Get +#### type BufferIdᵖ ```go -func (m BufferPtr_BufferIdMap) Get(key BufferId) *Buffer +type BufferIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (BufferPtr_BufferIdMap) Range +BufferIdᵖ is a pointer to a BufferId element. + +#### func NewBufferIdᵖ + +```go +func NewBufferIdᵖ(addr memory.Pointer) BufferIdᵖ +``` +NewBufferIdᵖ returns a BufferIdᵖ that points to addr in the application pool. + +#### func (*BufferIdᵖ) Class + +```go +func (*BufferIdᵖ) Class() binary.Class +``` + +#### func (BufferIdᵖ) ElementSize + +```go +func (p BufferIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that BufferIdᵖ points to. + +#### func (BufferIdᵖ) Read + +```go +func (p BufferIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) BufferId +``` +Read reads and returns the BufferId element at the pointer. + +#### func (BufferIdᵖ) Slice + +```go +func (p BufferIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) BufferIdˢ +``` +Slice returns a new BufferIdˢ from the pointer using start and end indices. + +#### func (BufferIdᵖ) String + +```go +func (p BufferIdᵖ) String() string +``` +String returns a string description of the BufferIdᵖ pointer. + +#### func (BufferIdᵖ) Write + +```go +func (p BufferIdᵖ) Write(value BufferId, ϟs *gfxapi.State) +``` +Write writes value to the BufferId element at the pointer. + +#### type BufferParameter + +```go +type BufferParameter uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum BufferParameter +////////////////////////////////////////////////////////////////////////////// + +#### func (*BufferParameter) Parse + +```go +func (v *BufferParameter) Parse(s string) error +``` + +#### func (BufferParameter) String ```go -func (m BufferPtr_BufferIdMap) Range() []*Buffer +func (v BufferParameter) String() string ``` #### type BufferTarget @@ -1738,12 +2345,49 @@ type BufferTarget uint32 enum BufferTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*BufferTarget) Parse + +```go +func (v *BufferTarget) Parse(s string) error +``` + #### func (BufferTarget) String ```go func (v BufferTarget) String() string ``` +#### type BufferTargetːBufferIdᵐ + +```go +type BufferTargetːBufferIdᵐ map[BufferTarget]BufferId +``` + + +#### func (BufferTargetːBufferIdᵐ) Contains + +```go +func (m BufferTargetːBufferIdᵐ) Contains(key BufferTarget) bool +``` + +#### func (BufferTargetːBufferIdᵐ) Delete + +```go +func (m BufferTargetːBufferIdᵐ) Delete(key BufferTarget) +``` + +#### func (BufferTargetːBufferIdᵐ) Get + +```go +func (m BufferTargetːBufferIdᵐ) Get(key BufferTarget) BufferId +``` + +#### func (BufferTargetːBufferIdᵐ) Range + +```go +func (m BufferTargetːBufferIdᵐ) Range() []BufferId +``` + #### type BufferUsage ```go @@ -1754,6 +2398,12 @@ type BufferUsage uint32 enum BufferUsage ////////////////////////////////////////////////////////////////////////////// +#### func (*BufferUsage) Parse + +```go +func (v *BufferUsage) Parse(s string) error +``` + #### func (BufferUsage) String ```go @@ -1763,30 +2413,279 @@ func (v BufferUsage) String() string #### type CGLContextObj ```go -type CGLContextObj memory.Pointer +type CGLContextObj struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGLContextObj is a pointer to a void element. + +#### func NewCGLContextObj + +```go +func NewCGLContextObj(addr memory.Pointer) CGLContextObj +``` +NewCGLContextObj returns a CGLContextObj that points to addr in the application +pool. + +#### func (*CGLContextObj) Class + +```go +func (*CGLContextObj) Class() binary.Class +``` + +#### func (CGLContextObj) ElementSize + +```go +func (p CGLContextObj) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGLContextObj points +to. + +#### func (CGLContextObj) Slice + +```go +func (p CGLContextObj) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (CGLContextObj) String + +```go +func (p CGLContextObj) String() string +``` +String returns a string description of the CGLContextObj pointer. + +#### type CGLContextObjːContextʳᵐ + +```go +type CGLContextObjːContextʳᵐ map[CGLContextObj](*Context) +``` + + +#### func (CGLContextObjːContextʳᵐ) Contains + +```go +func (m CGLContextObjːContextʳᵐ) Contains(key CGLContextObj) bool +``` + +#### func (CGLContextObjːContextʳᵐ) Delete + +```go +func (m CGLContextObjːContextʳᵐ) Delete(key CGLContextObj) +``` + +#### func (CGLContextObjːContextʳᵐ) Get + +```go +func (m CGLContextObjːContextʳᵐ) Get(key CGLContextObj) *Context +``` + +#### func (CGLContextObjːContextʳᵐ) Range + +```go +func (m CGLContextObjːContextʳᵐ) Range() [](*Context) +``` + +#### type CGLContextObjˢ + +```go +type CGLContextObjˢ struct { + binary.Generate + SliceInfo +} +``` + +CGLContextObjˢ is a slice of CGLContextObj. + +#### func AsCGLContextObjˢ + +```go +func AsCGLContextObjˢ(s Slice, ϟs *gfxapi.State) CGLContextObjˢ +``` +AsCGLContextObjˢ returns s cast to a CGLContextObjˢ. The returned slice length +will be calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeCGLContextObjˢ + +```go +func MakeCGLContextObjˢ(count uint64, ϟs *gfxapi.State) CGLContextObjˢ +``` +MakeCGLContextObjˢ returns a CGLContextObjˢ backed by a new memory pool. + +#### func (*CGLContextObjˢ) Class + +```go +func (*CGLContextObjˢ) Class() binary.Class +``` + +#### func (CGLContextObjˢ) Clone + +```go +func (s CGLContextObjˢ) Clone(ϟs *gfxapi.State) CGLContextObjˢ +``` +Clone returns a copy of the CGLContextObjˢ in a new memory pool. + +#### func (CGLContextObjˢ) Copy + +```go +func (dst CGLContextObjˢ) Copy(src CGLContextObjˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s CGLContextObjˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (CGLContextObjˢ) Decoder + +```go +func (s CGLContextObjˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (CGLContextObjˢ) ElementSize + +```go +func (s CGLContextObjˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGLContextObjˢ points +to. + +#### func (CGLContextObjˢ) Encoder + +```go +func (s CGLContextObjˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (CGLContextObjˢ) Index + +```go +func (s CGLContextObjˢ) Index(i uint64, ϟs *gfxapi.State) CGLContextObjᵖ +``` +Index returns a CGLContextObjᵖ to the i'th element in this CGLContextObjˢ. + +#### func (CGLContextObjˢ) Range + +```go +func (s CGLContextObjˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (CGLContextObjˢ) Read + +```go +func (s CGLContextObjˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []CGLContextObj +``` +Read reads and returns all the CGLContextObj elements in this CGLContextObjˢ. + +#### func (CGLContextObjˢ) ResourceID + +```go +func (s CGLContextObjˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (CGLContextObjˢ) Slice + +```go +func (s CGLContextObjˢ) Slice(start, end uint64, ϟs *gfxapi.State) CGLContextObjˢ +``` +Slice returns a sub-slice from the CGLContextObjˢ using start and end indices. + +#### func (CGLContextObjˢ) String + +```go +func (s CGLContextObjˢ) String() string +``` +String returns a string description of the CGLContextObjˢ slice. + +#### func (CGLContextObjˢ) Write + +```go +func (dst CGLContextObjˢ) Write(src []CGLContextObj, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type CGLContextObjᵖ + +```go +type CGLContextObjᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGLContextObjᵖ is a pointer to a CGLContextObj element. Note: Pointers are +stored differently between the application pool and internal pools. + + * The application pool stores pointers as an address an architecture-dependant size. + * Internal pools store pointers as an 64-bit unsigned address and a 32-bit unsigned + pool identifier. + +#### func NewCGLContextObjᵖ + +```go +func NewCGLContextObjᵖ(addr memory.Pointer) CGLContextObjᵖ ``` +NewCGLContextObjᵖ returns a CGLContextObjᵖ that points to addr in the +application pool. + +#### func (*CGLContextObjᵖ) Class +```go +func (*CGLContextObjᵖ) Class() binary.Class +``` -#### func (*CGLContextObj) Equal +#### func (CGLContextObjᵖ) ElementSize ```go -func (c *CGLContextObj) Equal(rhs CGLContextObj) bool +func (p CGLContextObjᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that CGLContextObjᵖ points +to. -#### func (*CGLContextObj) Less +#### func (CGLContextObjᵖ) Read ```go -func (c *CGLContextObj) Less(rhs CGLContextObj) bool +func (p CGLContextObjᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) CGLContextObj ``` +Read reads and returns the CGLContextObj element at the pointer. + +#### func (CGLContextObjᵖ) Slice + +```go +func (p CGLContextObjᵖ) Slice(start, end uint64, ϟs *gfxapi.State) CGLContextObjˢ +``` +Slice returns a new CGLContextObjˢ from the pointer using start and end indices. + +#### func (CGLContextObjᵖ) String + +```go +func (p CGLContextObjᵖ) String() string +``` +String returns a string description of the CGLContextObjᵖ pointer. + +#### func (CGLContextObjᵖ) Write + +```go +func (p CGLContextObjᵖ) Write(value CGLContextObj, ϟs *gfxapi.State) +``` +Write writes value to the CGLContextObj element at the pointer. #### type CGLCreateContext ```go type CGLCreateContext struct { binary.Generate + Pix CGLPixelFormatObj Share CGLContextObj - Ctx CGLContextObj + Ctx CGLContextObjᵖ Result CGLError } ``` @@ -1798,12 +2697,7 @@ CGLCreateContext #### func NewCGLCreateContext ```go -func NewCGLCreateContext( - pPix CGLPixelFormatObj, - pShare CGLContextObj, - pCtx CGLContextObj, - pResult CGLError, -) *CGLCreateContext +func NewCGLCreateContext(Pix memory.Pointer, Share memory.Pointer, Ctx memory.Pointer, Result CGLError) *CGLCreateContext ``` #### func (*CGLCreateContext) API @@ -1812,6 +2706,22 @@ func NewCGLCreateContext( func (c *CGLCreateContext) API() gfxapi.API ``` +#### func (*CGLCreateContext) AddRead + +```go +func (a *CGLCreateContext) AddRead(rng memory.Range, id binary.ID) *CGLCreateContext +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CGLCreateContext pointer is returned so that calls can be chained. + +#### func (*CGLCreateContext) AddWrite + +```go +func (a *CGLCreateContext) AddWrite(rng memory.Range, id binary.ID) *CGLCreateContext +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CGLCreateContext pointer is returned so that calls can be chained. + #### func (*CGLCreateContext) Class ```go @@ -1827,19 +2737,25 @@ func (c *CGLCreateContext) Flags() atom.Flags #### func (*CGLCreateContext) Mutate ```go -func (ϟa *CGLCreateContext) Mutate(ϟs *gfxapi.State) error +func (ϟa *CGLCreateContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CGLCreateContext) Observations + +```go +func (a *CGLCreateContext) Observations() *atom.Observations ``` #### func (*CGLCreateContext) Replay ```go -func (ω *CGLCreateContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (ω *CGLCreateContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` #### func (*CGLCreateContext) String ```go -func (c *CGLCreateContext) String() string +func (a *CGLCreateContext) String() string ``` #### func (*CGLCreateContext) TypeID @@ -1848,65 +2764,228 @@ func (c *CGLCreateContext) String() string func (c *CGLCreateContext) TypeID() atom.TypeID ``` -#### type CGLCreateContext_Postback +#### type CGLError + +```go +type CGLError int64 +``` + + +#### type CGLFlushDrawable ```go -type CGLCreateContext_Postback struct { - Ctx []byte +type CGLFlushDrawable struct { + binary.Generate + + Ctx CGLContextObj Result CGLError } ``` +////////////////////////////////////////////////////////////////////////////// +CGLFlushDrawable +////////////////////////////////////////////////////////////////////////////// -#### func (*CGLCreateContext_Postback) Decode +#### func NewCGLFlushDrawable ```go -func (o *CGLCreateContext_Postback) Decode(ctx_cnt uint64, d binary.Decoder) error +func NewCGLFlushDrawable(Ctx memory.Pointer, Result CGLError) *CGLFlushDrawable ``` -#### type CGLError +#### func (*CGLFlushDrawable) API ```go -type CGLError int64 +func (c *CGLFlushDrawable) API() gfxapi.API +``` + +#### func (*CGLFlushDrawable) AddRead + +```go +func (a *CGLFlushDrawable) AddRead(rng memory.Range, id binary.ID) *CGLFlushDrawable +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CGLFlushDrawable pointer is returned so that calls can be chained. + +#### func (*CGLFlushDrawable) AddWrite + +```go +func (a *CGLFlushDrawable) AddWrite(rng memory.Range, id binary.ID) *CGLFlushDrawable +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CGLFlushDrawable pointer is returned so that calls can be chained. + +#### func (*CGLFlushDrawable) Class + +```go +func (*CGLFlushDrawable) Class() binary.Class +``` + +#### func (*CGLFlushDrawable) Flags + +```go +func (c *CGLFlushDrawable) Flags() atom.Flags +``` + +#### func (*CGLFlushDrawable) Mutate + +```go +func (ϟa *CGLFlushDrawable) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` +#### func (*CGLFlushDrawable) Observations + +```go +func (a *CGLFlushDrawable) Observations() *atom.Observations +``` + +#### func (*CGLFlushDrawable) String + +```go +func (a *CGLFlushDrawable) String() string +``` + +#### func (*CGLFlushDrawable) TypeID + +```go +func (c *CGLFlushDrawable) TypeID() atom.TypeID +``` + +#### type CGLGetSurface + +```go +type CGLGetSurface struct { + binary.Generate + + Ctx CGLContextObj + Cid CGSConnectionIDᵖ + Wid CGSWindowIDᵖ + Sid CGSSurfaceIDᵖ + Result int64 +} +``` + +////////////////////////////////////////////////////////////////////////////// +CGLGetSurface +////////////////////////////////////////////////////////////////////////////// + +#### func NewCGLGetSurface + +```go +func NewCGLGetSurface(Ctx memory.Pointer, Cid memory.Pointer, Wid memory.Pointer, Sid memory.Pointer, Result int64) *CGLGetSurface +``` -#### func (*CGLError) Equal +#### func (*CGLGetSurface) API ```go -func (c *CGLError) Equal(rhs CGLError) bool +func (c *CGLGetSurface) API() gfxapi.API ``` -#### func (*CGLError) Less +#### func (*CGLGetSurface) AddRead ```go -func (c *CGLError) Less(rhs CGLError) bool +func (a *CGLGetSurface) AddRead(rng memory.Range, id binary.ID) *CGLGetSurface +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CGLGetSurface pointer is returned so that calls can be chained. + +#### func (*CGLGetSurface) AddWrite + +```go +func (a *CGLGetSurface) AddWrite(rng memory.Range, id binary.ID) *CGLGetSurface +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CGLGetSurface pointer is returned so that calls can be chained. + +#### func (*CGLGetSurface) Class + +```go +func (*CGLGetSurface) Class() binary.Class +``` + +#### func (*CGLGetSurface) Flags + +```go +func (c *CGLGetSurface) Flags() atom.Flags +``` + +#### func (*CGLGetSurface) Mutate + +```go +func (ϟa *CGLGetSurface) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CGLGetSurface) Observations + +```go +func (a *CGLGetSurface) Observations() *atom.Observations +``` + +#### func (*CGLGetSurface) String + +```go +func (a *CGLGetSurface) String() string +``` + +#### func (*CGLGetSurface) TypeID + +```go +func (c *CGLGetSurface) TypeID() atom.TypeID ``` #### type CGLPixelFormatObj ```go -type CGLPixelFormatObj memory.Pointer +type CGLPixelFormatObj struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGLPixelFormatObj is a pointer to a void element. + +#### func NewCGLPixelFormatObj + +```go +func NewCGLPixelFormatObj(addr memory.Pointer) CGLPixelFormatObj ``` +NewCGLPixelFormatObj returns a CGLPixelFormatObj that points to addr in the +application pool. +#### func (*CGLPixelFormatObj) Class -#### func (*CGLPixelFormatObj) Equal +```go +func (*CGLPixelFormatObj) Class() binary.Class +``` + +#### func (CGLPixelFormatObj) ElementSize ```go -func (c *CGLPixelFormatObj) Equal(rhs CGLPixelFormatObj) bool +func (p CGLPixelFormatObj) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that CGLPixelFormatObj +points to. -#### func (*CGLPixelFormatObj) Less +#### func (CGLPixelFormatObj) Slice ```go -func (c *CGLPixelFormatObj) Less(rhs CGLPixelFormatObj) bool +func (p CGLPixelFormatObj) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (CGLPixelFormatObj) String + +```go +func (p CGLPixelFormatObj) String() string +``` +String returns a string description of the CGLPixelFormatObj pointer. #### type CGLSetCurrentContext ```go type CGLSetCurrentContext struct { binary.Generate + Ctx CGLContextObj Result CGLError } @@ -1919,10 +2998,7 @@ CGLSetCurrentContext #### func NewCGLSetCurrentContext ```go -func NewCGLSetCurrentContext( - pCtx CGLContextObj, - pResult CGLError, -) *CGLSetCurrentContext +func NewCGLSetCurrentContext(Ctx memory.Pointer, Result CGLError) *CGLSetCurrentContext ``` #### func (*CGLSetCurrentContext) API @@ -1931,6 +3007,24 @@ func NewCGLSetCurrentContext( func (c *CGLSetCurrentContext) API() gfxapi.API ``` +#### func (*CGLSetCurrentContext) AddRead + +```go +func (a *CGLSetCurrentContext) AddRead(rng memory.Range, id binary.ID) *CGLSetCurrentContext +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CGLSetCurrentContext pointer is returned so that calls can be +chained. + +#### func (*CGLSetCurrentContext) AddWrite + +```go +func (a *CGLSetCurrentContext) AddWrite(rng memory.Range, id binary.ID) *CGLSetCurrentContext +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CGLSetCurrentContext pointer is returned so that calls can be +chained. + #### func (*CGLSetCurrentContext) Class ```go @@ -1946,19 +3040,25 @@ func (c *CGLSetCurrentContext) Flags() atom.Flags #### func (*CGLSetCurrentContext) Mutate ```go -func (ϟa *CGLSetCurrentContext) Mutate(ϟs *gfxapi.State) error +func (ϟa *CGLSetCurrentContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CGLSetCurrentContext) Observations + +```go +func (a *CGLSetCurrentContext) Observations() *atom.Observations ``` #### func (*CGLSetCurrentContext) Replay ```go -func (ω *CGLSetCurrentContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (ω *CGLSetCurrentContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` #### func (*CGLSetCurrentContext) String ```go -func (c *CGLSetCurrentContext) String() string +func (a *CGLSetCurrentContext) String() string ``` #### func (*CGLSetCurrentContext) TypeID @@ -1967,20 +3067,706 @@ func (c *CGLSetCurrentContext) String() string func (c *CGLSetCurrentContext) TypeID() atom.TypeID ``` -#### type CGLSetCurrentContext_Postback +#### type CGSConnectionID ```go -type CGLSetCurrentContext_Postback struct { - Result CGLError +type CGSConnectionID struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGSConnectionID is a pointer to a void element. + +#### func NewCGSConnectionID + +```go +func NewCGSConnectionID(addr memory.Pointer) CGSConnectionID +``` +NewCGSConnectionID returns a CGSConnectionID that points to addr in the +application pool. + +#### func (*CGSConnectionID) Class + +```go +func (*CGSConnectionID) Class() binary.Class +``` + +#### func (CGSConnectionID) ElementSize + +```go +func (p CGSConnectionID) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSConnectionID points +to. + +#### func (CGSConnectionID) Slice + +```go +func (p CGSConnectionID) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (CGSConnectionID) String + +```go +func (p CGSConnectionID) String() string +``` +String returns a string description of the CGSConnectionID pointer. + +#### type CGSConnectionIDˢ + +```go +type CGSConnectionIDˢ struct { + binary.Generate + SliceInfo +} +``` + +CGSConnectionIDˢ is a slice of CGSConnectionID. + +#### func AsCGSConnectionIDˢ + +```go +func AsCGSConnectionIDˢ(s Slice, ϟs *gfxapi.State) CGSConnectionIDˢ +``` +AsCGSConnectionIDˢ returns s cast to a CGSConnectionIDˢ. The returned slice +length will be calculated so that the returned slice is no longer (in bytes) +than s. + +#### func MakeCGSConnectionIDˢ + +```go +func MakeCGSConnectionIDˢ(count uint64, ϟs *gfxapi.State) CGSConnectionIDˢ +``` +MakeCGSConnectionIDˢ returns a CGSConnectionIDˢ backed by a new memory pool. + +#### func (*CGSConnectionIDˢ) Class + +```go +func (*CGSConnectionIDˢ) Class() binary.Class +``` + +#### func (CGSConnectionIDˢ) Clone + +```go +func (s CGSConnectionIDˢ) Clone(ϟs *gfxapi.State) CGSConnectionIDˢ +``` +Clone returns a copy of the CGSConnectionIDˢ in a new memory pool. + +#### func (CGSConnectionIDˢ) Copy + +```go +func (dst CGSConnectionIDˢ) Copy(src CGSConnectionIDˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s CGSConnectionIDˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (CGSConnectionIDˢ) Decoder + +```go +func (s CGSConnectionIDˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (CGSConnectionIDˢ) ElementSize + +```go +func (s CGSConnectionIDˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSConnectionIDˢ points +to. + +#### func (CGSConnectionIDˢ) Encoder + +```go +func (s CGSConnectionIDˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (CGSConnectionIDˢ) Index + +```go +func (s CGSConnectionIDˢ) Index(i uint64, ϟs *gfxapi.State) CGSConnectionIDᵖ +``` +Index returns a CGSConnectionIDᵖ to the i'th element in this CGSConnectionIDˢ. + +#### func (CGSConnectionIDˢ) Range + +```go +func (s CGSConnectionIDˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (CGSConnectionIDˢ) Read + +```go +func (s CGSConnectionIDˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []CGSConnectionID +``` +Read reads and returns all the CGSConnectionID elements in this +CGSConnectionIDˢ. + +#### func (CGSConnectionIDˢ) ResourceID + +```go +func (s CGSConnectionIDˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (CGSConnectionIDˢ) Slice + +```go +func (s CGSConnectionIDˢ) Slice(start, end uint64, ϟs *gfxapi.State) CGSConnectionIDˢ +``` +Slice returns a sub-slice from the CGSConnectionIDˢ using start and end indices. + +#### func (CGSConnectionIDˢ) String + +```go +func (s CGSConnectionIDˢ) String() string +``` +String returns a string description of the CGSConnectionIDˢ slice. + +#### func (CGSConnectionIDˢ) Write + +```go +func (dst CGSConnectionIDˢ) Write(src []CGSConnectionID, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type CGSConnectionIDᵖ + +```go +type CGSConnectionIDᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGSConnectionIDᵖ is a pointer to a CGSConnectionID element. Note: Pointers are +stored differently between the application pool and internal pools. + + * The application pool stores pointers as an address an architecture-dependant size. + * Internal pools store pointers as an 64-bit unsigned address and a 32-bit unsigned + pool identifier. + +#### func NewCGSConnectionIDᵖ + +```go +func NewCGSConnectionIDᵖ(addr memory.Pointer) CGSConnectionIDᵖ +``` +NewCGSConnectionIDᵖ returns a CGSConnectionIDᵖ that points to addr in the +application pool. + +#### func (*CGSConnectionIDᵖ) Class + +```go +func (*CGSConnectionIDᵖ) Class() binary.Class +``` + +#### func (CGSConnectionIDᵖ) ElementSize + +```go +func (p CGSConnectionIDᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSConnectionIDᵖ points +to. + +#### func (CGSConnectionIDᵖ) Read + +```go +func (p CGSConnectionIDᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) CGSConnectionID +``` +Read reads and returns the CGSConnectionID element at the pointer. + +#### func (CGSConnectionIDᵖ) Slice + +```go +func (p CGSConnectionIDᵖ) Slice(start, end uint64, ϟs *gfxapi.State) CGSConnectionIDˢ +``` +Slice returns a new CGSConnectionIDˢ from the pointer using start and end +indices. + +#### func (CGSConnectionIDᵖ) String + +```go +func (p CGSConnectionIDᵖ) String() string +``` +String returns a string description of the CGSConnectionIDᵖ pointer. + +#### func (CGSConnectionIDᵖ) Write + +```go +func (p CGSConnectionIDᵖ) Write(value CGSConnectionID, ϟs *gfxapi.State) +``` +Write writes value to the CGSConnectionID element at the pointer. + +#### type CGSGetSurfaceBounds + +```go +type CGSGetSurfaceBounds struct { + binary.Generate + + Cid CGSConnectionID + Wid CGSWindowID + Sid CGSSurfaceID + Bounds F64ᵖ + Result int64 +} +``` + +////////////////////////////////////////////////////////////////////////////// +CGSGetSurfaceBounds +////////////////////////////////////////////////////////////////////////////// + +#### func NewCGSGetSurfaceBounds + +```go +func NewCGSGetSurfaceBounds(Cid memory.Pointer, Wid CGSWindowID, Sid CGSSurfaceID, Bounds memory.Pointer, Result int64) *CGSGetSurfaceBounds +``` + +#### func (*CGSGetSurfaceBounds) API + +```go +func (c *CGSGetSurfaceBounds) API() gfxapi.API +``` + +#### func (*CGSGetSurfaceBounds) AddRead + +```go +func (a *CGSGetSurfaceBounds) AddRead(rng memory.Range, id binary.ID) *CGSGetSurfaceBounds +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CGSGetSurfaceBounds pointer is returned so that calls can be +chained. + +#### func (*CGSGetSurfaceBounds) AddWrite + +```go +func (a *CGSGetSurfaceBounds) AddWrite(rng memory.Range, id binary.ID) *CGSGetSurfaceBounds +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CGSGetSurfaceBounds pointer is returned so that calls can be +chained. + +#### func (*CGSGetSurfaceBounds) Class + +```go +func (*CGSGetSurfaceBounds) Class() binary.Class +``` + +#### func (*CGSGetSurfaceBounds) Flags + +```go +func (c *CGSGetSurfaceBounds) Flags() atom.Flags +``` + +#### func (*CGSGetSurfaceBounds) Mutate + +```go +func (ϟa *CGSGetSurfaceBounds) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CGSGetSurfaceBounds) Observations + +```go +func (a *CGSGetSurfaceBounds) Observations() *atom.Observations +``` + +#### func (*CGSGetSurfaceBounds) String + +```go +func (a *CGSGetSurfaceBounds) String() string +``` + +#### func (*CGSGetSurfaceBounds) TypeID + +```go +func (c *CGSGetSurfaceBounds) TypeID() atom.TypeID +``` + +#### type CGSSurfaceID + +```go +type CGSSurfaceID int32 +``` + + +#### type CGSSurfaceIDˢ + +```go +type CGSSurfaceIDˢ struct { + binary.Generate + SliceInfo +} +``` + +CGSSurfaceIDˢ is a slice of CGSSurfaceID. + +#### func AsCGSSurfaceIDˢ + +```go +func AsCGSSurfaceIDˢ(s Slice, ϟs *gfxapi.State) CGSSurfaceIDˢ +``` +AsCGSSurfaceIDˢ returns s cast to a CGSSurfaceIDˢ. The returned slice length +will be calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeCGSSurfaceIDˢ + +```go +func MakeCGSSurfaceIDˢ(count uint64, ϟs *gfxapi.State) CGSSurfaceIDˢ +``` +MakeCGSSurfaceIDˢ returns a CGSSurfaceIDˢ backed by a new memory pool. + +#### func (*CGSSurfaceIDˢ) Class + +```go +func (*CGSSurfaceIDˢ) Class() binary.Class +``` + +#### func (CGSSurfaceIDˢ) Clone + +```go +func (s CGSSurfaceIDˢ) Clone(ϟs *gfxapi.State) CGSSurfaceIDˢ +``` +Clone returns a copy of the CGSSurfaceIDˢ in a new memory pool. + +#### func (CGSSurfaceIDˢ) Copy + +```go +func (dst CGSSurfaceIDˢ) Copy(src CGSSurfaceIDˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s CGSSurfaceIDˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (CGSSurfaceIDˢ) Decoder + +```go +func (s CGSSurfaceIDˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (CGSSurfaceIDˢ) ElementSize + +```go +func (s CGSSurfaceIDˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSSurfaceIDˢ points +to. + +#### func (CGSSurfaceIDˢ) Encoder + +```go +func (s CGSSurfaceIDˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (CGSSurfaceIDˢ) Index + +```go +func (s CGSSurfaceIDˢ) Index(i uint64, ϟs *gfxapi.State) CGSSurfaceIDᵖ +``` +Index returns a CGSSurfaceIDᵖ to the i'th element in this CGSSurfaceIDˢ. + +#### func (CGSSurfaceIDˢ) Range + +```go +func (s CGSSurfaceIDˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (CGSSurfaceIDˢ) Read + +```go +func (s CGSSurfaceIDˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []CGSSurfaceID +``` +Read reads and returns all the CGSSurfaceID elements in this CGSSurfaceIDˢ. + +#### func (CGSSurfaceIDˢ) ResourceID + +```go +func (s CGSSurfaceIDˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (CGSSurfaceIDˢ) Slice + +```go +func (s CGSSurfaceIDˢ) Slice(start, end uint64, ϟs *gfxapi.State) CGSSurfaceIDˢ +``` +Slice returns a sub-slice from the CGSSurfaceIDˢ using start and end indices. + +#### func (CGSSurfaceIDˢ) String + +```go +func (s CGSSurfaceIDˢ) String() string +``` +String returns a string description of the CGSSurfaceIDˢ slice. + +#### func (CGSSurfaceIDˢ) Write + +```go +func (dst CGSSurfaceIDˢ) Write(src []CGSSurfaceID, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type CGSSurfaceIDᵖ + +```go +type CGSSurfaceIDᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +CGSSurfaceIDᵖ is a pointer to a CGSSurfaceID element. + +#### func NewCGSSurfaceIDᵖ + +```go +func NewCGSSurfaceIDᵖ(addr memory.Pointer) CGSSurfaceIDᵖ +``` +NewCGSSurfaceIDᵖ returns a CGSSurfaceIDᵖ that points to addr in the application +pool. + +#### func (*CGSSurfaceIDᵖ) Class + +```go +func (*CGSSurfaceIDᵖ) Class() binary.Class +``` + +#### func (CGSSurfaceIDᵖ) ElementSize + +```go +func (p CGSSurfaceIDᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSSurfaceIDᵖ points +to. + +#### func (CGSSurfaceIDᵖ) Read + +```go +func (p CGSSurfaceIDᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) CGSSurfaceID +``` +Read reads and returns the CGSSurfaceID element at the pointer. + +#### func (CGSSurfaceIDᵖ) Slice + +```go +func (p CGSSurfaceIDᵖ) Slice(start, end uint64, ϟs *gfxapi.State) CGSSurfaceIDˢ +``` +Slice returns a new CGSSurfaceIDˢ from the pointer using start and end indices. + +#### func (CGSSurfaceIDᵖ) String + +```go +func (p CGSSurfaceIDᵖ) String() string +``` +String returns a string description of the CGSSurfaceIDᵖ pointer. + +#### func (CGSSurfaceIDᵖ) Write + +```go +func (p CGSSurfaceIDᵖ) Write(value CGSSurfaceID, ϟs *gfxapi.State) +``` +Write writes value to the CGSSurfaceID element at the pointer. + +#### type CGSWindowID + +```go +type CGSWindowID int32 +``` + + +#### type CGSWindowIDˢ + +```go +type CGSWindowIDˢ struct { + binary.Generate + SliceInfo +} +``` + +CGSWindowIDˢ is a slice of CGSWindowID. + +#### func AsCGSWindowIDˢ + +```go +func AsCGSWindowIDˢ(s Slice, ϟs *gfxapi.State) CGSWindowIDˢ +``` +AsCGSWindowIDˢ returns s cast to a CGSWindowIDˢ. The returned slice length will +be calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeCGSWindowIDˢ + +```go +func MakeCGSWindowIDˢ(count uint64, ϟs *gfxapi.State) CGSWindowIDˢ +``` +MakeCGSWindowIDˢ returns a CGSWindowIDˢ backed by a new memory pool. + +#### func (*CGSWindowIDˢ) Class + +```go +func (*CGSWindowIDˢ) Class() binary.Class +``` + +#### func (CGSWindowIDˢ) Clone + +```go +func (s CGSWindowIDˢ) Clone(ϟs *gfxapi.State) CGSWindowIDˢ +``` +Clone returns a copy of the CGSWindowIDˢ in a new memory pool. + +#### func (CGSWindowIDˢ) Copy + +```go +func (dst CGSWindowIDˢ) Copy(src CGSWindowIDˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s CGSWindowIDˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (CGSWindowIDˢ) Decoder + +```go +func (s CGSWindowIDˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (CGSWindowIDˢ) ElementSize + +```go +func (s CGSWindowIDˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSWindowIDˢ points to. + +#### func (CGSWindowIDˢ) Encoder + +```go +func (s CGSWindowIDˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (CGSWindowIDˢ) Index + +```go +func (s CGSWindowIDˢ) Index(i uint64, ϟs *gfxapi.State) CGSWindowIDᵖ +``` +Index returns a CGSWindowIDᵖ to the i'th element in this CGSWindowIDˢ. + +#### func (CGSWindowIDˢ) Range + +```go +func (s CGSWindowIDˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (CGSWindowIDˢ) Read + +```go +func (s CGSWindowIDˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []CGSWindowID +``` +Read reads and returns all the CGSWindowID elements in this CGSWindowIDˢ. + +#### func (CGSWindowIDˢ) ResourceID + +```go +func (s CGSWindowIDˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (CGSWindowIDˢ) Slice + +```go +func (s CGSWindowIDˢ) Slice(start, end uint64, ϟs *gfxapi.State) CGSWindowIDˢ +``` +Slice returns a sub-slice from the CGSWindowIDˢ using start and end indices. + +#### func (CGSWindowIDˢ) String + +```go +func (s CGSWindowIDˢ) String() string +``` +String returns a string description of the CGSWindowIDˢ slice. + +#### func (CGSWindowIDˢ) Write + +```go +func (dst CGSWindowIDˢ) Write(src []CGSWindowID, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type CGSWindowIDᵖ + +```go +type CGSWindowIDᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID } ``` +CGSWindowIDᵖ is a pointer to a CGSWindowID element. + +#### func NewCGSWindowIDᵖ + +```go +func NewCGSWindowIDᵖ(addr memory.Pointer) CGSWindowIDᵖ +``` +NewCGSWindowIDᵖ returns a CGSWindowIDᵖ that points to addr in the application +pool. + +#### func (*CGSWindowIDᵖ) Class + +```go +func (*CGSWindowIDᵖ) Class() binary.Class +``` + +#### func (CGSWindowIDᵖ) ElementSize + +```go +func (p CGSWindowIDᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that CGSWindowIDᵖ points to. + +#### func (CGSWindowIDᵖ) Read + +```go +func (p CGSWindowIDᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) CGSWindowID +``` +Read reads and returns the CGSWindowID element at the pointer. + +#### func (CGSWindowIDᵖ) Slice + +```go +func (p CGSWindowIDᵖ) Slice(start, end uint64, ϟs *gfxapi.State) CGSWindowIDˢ +``` +Slice returns a new CGSWindowIDˢ from the pointer using start and end indices. + +#### func (CGSWindowIDᵖ) String + +```go +func (p CGSWindowIDᵖ) String() string +``` +String returns a string description of the CGSWindowIDᵖ pointer. -#### func (*CGLSetCurrentContext_Postback) Decode +#### func (CGSWindowIDᵖ) Write ```go -func (o *CGLSetCurrentContext_Postback) Decode(d binary.Decoder) error +func (p CGSWindowIDᵖ) Write(value CGSWindowID, ϟs *gfxapi.State) ``` +Write writes value to the CGSWindowID element at the pointer. #### type Capability @@ -1992,30 +3778,430 @@ type Capability uint32 enum Capability ////////////////////////////////////////////////////////////////////////////// +#### func (*Capability) Parse + +```go +func (v *Capability) Parse(s string) error +``` + #### func (Capability) String ```go func (v Capability) String() string ``` -#### type CharBufferArray +#### type Capabilityːboolᵐ + +```go +type Capabilityːboolᵐ map[Capability]bool +``` + + +#### func (Capabilityːboolᵐ) Contains + +```go +func (m Capabilityːboolᵐ) Contains(key Capability) bool +``` + +#### func (Capabilityːboolᵐ) Delete + +```go +func (m Capabilityːboolᵐ) Delete(key Capability) +``` + +#### func (Capabilityːboolᵐ) Get ```go -type CharBufferArray []string +func (m Capabilityːboolᵐ) Get(key Capability) bool ``` +#### func (Capabilityːboolᵐ) Range + +```go +func (m Capabilityːboolᵐ) Range() []bool +``` + +#### type Charˢ + +```go +type Charˢ struct { + binary.Generate + SliceInfo +} +``` + +Charˢ is a slice of byte. + +#### func AsCharˢ + +```go +func AsCharˢ(s Slice, ϟs *gfxapi.State) Charˢ +``` +AsCharˢ returns s cast to a Charˢ. The returned slice length will be calculated +so that the returned slice is no longer (in bytes) than s. + +#### func MakeCharˢ + +```go +func MakeCharˢ(count uint64, ϟs *gfxapi.State) Charˢ +``` +MakeCharˢ returns a Charˢ backed by a new memory pool. + +#### func MakeCharˢFromString + +```go +func MakeCharˢFromString(str string, ϟs *gfxapi.State) Charˢ +``` +MakeCharˢFromString returns a Charˢ backed by a new memory pool containing a +copy of str. + +#### func (*Charˢ) Class + +```go +func (*Charˢ) Class() binary.Class +``` -#### func (CharBufferArray) Len +#### func (Charˢ) Clone ```go -func (s CharBufferArray) Len() int +func (s Charˢ) Clone(ϟs *gfxapi.State) Charˢ ``` +Clone returns a copy of the Charˢ in a new memory pool. -#### func (CharBufferArray) Range +#### func (Charˢ) Copy ```go -func (s CharBufferArray) Range() []string +func (dst Charˢ) Copy(src Charˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Charˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Charˢ) Decoder + +```go +func (s Charˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Charˢ) ElementSize + +```go +func (s Charˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charˢ points to. + +#### func (Charˢ) Encoder + +```go +func (s Charˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Charˢ) Index + +```go +func (s Charˢ) Index(i uint64, ϟs *gfxapi.State) Charᵖ +``` +Index returns a Charᵖ to the i'th element in this Charˢ. + +#### func (Charˢ) Range + +```go +func (s Charˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Charˢ) Read + +```go +func (s Charˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []byte +``` +Read reads and returns all the byte elements in this Charˢ. + +#### func (Charˢ) ResourceID + +```go +func (s Charˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Charˢ) Slice + +```go +func (s Charˢ) Slice(start, end uint64, ϟs *gfxapi.State) Charˢ +``` +Slice returns a sub-slice from the Charˢ using start and end indices. + +#### func (Charˢ) String + +```go +func (s Charˢ) String() string +``` +String returns a string description of the Charˢ slice. + +#### func (Charˢ) Write + +```go +func (dst Charˢ) Write(src []byte, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Charᵖ + +```go +type Charᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Charᵖ is a pointer to a byte element. + +#### func NewCharᵖ + +```go +func NewCharᵖ(addr memory.Pointer) Charᵖ +``` +NewCharᵖ returns a Charᵖ that points to addr in the application pool. + +#### func (*Charᵖ) Class + +```go +func (*Charᵖ) Class() binary.Class +``` + +#### func (Charᵖ) ElementSize + +```go +func (p Charᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charᵖ points to. + +#### func (Charᵖ) Read + +```go +func (p Charᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) byte +``` +Read reads and returns the byte element at the pointer. + +#### func (Charᵖ) Slice + +```go +func (p Charᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Charˢ +``` +Slice returns a new Charˢ from the pointer using start and end indices. + +#### func (Charᵖ) String + +```go +func (p Charᵖ) String() string +``` +String returns a string description of the Charᵖ pointer. + +#### func (Charᵖ) StringSlice + +```go +func (p Charᵖ) StringSlice(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, incNullTerm bool) Charˢ +``` +StringSlice returns a slice starting at p and ending at the first 0 byte +null-terminator. If incNullTerm is true then the null-terminator is included in +the slice. + +#### func (Charᵖ) Write + +```go +func (p Charᵖ) Write(value byte, ϟs *gfxapi.State) +``` +Write writes value to the byte element at the pointer. + +#### type Charᵖˢ + +```go +type Charᵖˢ struct { + binary.Generate + SliceInfo +} +``` + +Charᵖˢ is a slice of Charᵖ. + +#### func AsCharᵖˢ + +```go +func AsCharᵖˢ(s Slice, ϟs *gfxapi.State) Charᵖˢ +``` +AsCharᵖˢ returns s cast to a Charᵖˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeCharᵖˢ + +```go +func MakeCharᵖˢ(count uint64, ϟs *gfxapi.State) Charᵖˢ +``` +MakeCharᵖˢ returns a Charᵖˢ backed by a new memory pool. + +#### func (*Charᵖˢ) Class + +```go +func (*Charᵖˢ) Class() binary.Class +``` + +#### func (Charᵖˢ) Clone + +```go +func (s Charᵖˢ) Clone(ϟs *gfxapi.State) Charᵖˢ +``` +Clone returns a copy of the Charᵖˢ in a new memory pool. + +#### func (Charᵖˢ) Copy + +```go +func (dst Charᵖˢ) Copy(src Charᵖˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Charᵖˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Charᵖˢ) Decoder + +```go +func (s Charᵖˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Charᵖˢ) ElementSize + +```go +func (s Charᵖˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charᵖˢ points to. + +#### func (Charᵖˢ) Encoder + +```go +func (s Charᵖˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Charᵖˢ) Index + +```go +func (s Charᵖˢ) Index(i uint64, ϟs *gfxapi.State) Charᵖᵖ +``` +Index returns a Charᵖᵖ to the i'th element in this Charᵖˢ. + +#### func (Charᵖˢ) Range + +```go +func (s Charᵖˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Charᵖˢ) Read + +```go +func (s Charᵖˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Charᵖ +``` +Read reads and returns all the Charᵖ elements in this Charᵖˢ. + +#### func (Charᵖˢ) ResourceID + +```go +func (s Charᵖˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Charᵖˢ) Slice + +```go +func (s Charᵖˢ) Slice(start, end uint64, ϟs *gfxapi.State) Charᵖˢ +``` +Slice returns a sub-slice from the Charᵖˢ using start and end indices. + +#### func (Charᵖˢ) String + +```go +func (s Charᵖˢ) String() string +``` +String returns a string description of the Charᵖˢ slice. + +#### func (Charᵖˢ) Write + +```go +func (dst Charᵖˢ) Write(src []Charᵖ, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Charᵖᵖ + +```go +type Charᵖᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Charᵖᵖ is a pointer to a Charᵖ element. Note: Pointers are stored differently +between the application pool and internal pools. + + * The application pool stores pointers as an address an architecture-dependant size. + * Internal pools store pointers as an 64-bit unsigned address and a 32-bit unsigned + pool identifier. + +#### func NewCharᵖᵖ + +```go +func NewCharᵖᵖ(addr memory.Pointer) Charᵖᵖ +``` +NewCharᵖᵖ returns a Charᵖᵖ that points to addr in the application pool. + +#### func (*Charᵖᵖ) Class + +```go +func (*Charᵖᵖ) Class() binary.Class +``` + +#### func (Charᵖᵖ) ElementSize + +```go +func (p Charᵖᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charᵖᵖ points to. + +#### func (Charᵖᵖ) Read + +```go +func (p Charᵖᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Charᵖ +``` +Read reads and returns the Charᵖ element at the pointer. + +#### func (Charᵖᵖ) Slice + +```go +func (p Charᵖᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Charᵖˢ +``` +Slice returns a new Charᵖˢ from the pointer using start and end indices. + +#### func (Charᵖᵖ) String + +```go +func (p Charᵖᵖ) String() string +``` +String returns a string description of the Charᵖᵖ pointer. + +#### func (Charᵖᵖ) Write + +```go +func (p Charᵖᵖ) Write(value Charᵖ, ϟs *gfxapi.State) +``` +Write writes value to the Charᵖ element at the pointer. #### type ClearMask @@ -2027,6 +4213,12 @@ type ClearMask uint32 enum ClearMask ////////////////////////////////////////////////////////////////////////////// +#### func (*ClearMask) Parse + +```go +func (v *ClearMask) Parse(s string) error +``` + #### func (ClearMask) String ```go @@ -2067,6 +4259,28 @@ func (c *ClearState) GetCreatedAt() atom.ID func (c *ClearState) Init() ``` +#### type ClientWaitSyncSignal + +```go +type ClientWaitSyncSignal uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum ClientWaitSyncSignal +////////////////////////////////////////////////////////////////////////////// + +#### func (*ClientWaitSyncSignal) Parse + +```go +func (v *ClientWaitSyncSignal) Parse(s string) error +``` + +#### func (ClientWaitSyncSignal) String + +```go +func (v ClientWaitSyncSignal) String() string +``` + #### type Color ```go @@ -2118,6 +4332,12 @@ type CompressedTexelFormat uint32 enum CompressedTexelFormat ////////////////////////////////////////////////////////////////////////////// +#### func (*CompressedTexelFormat) Parse + +```go +func (v *CompressedTexelFormat) Parse(s string) error +``` + #### func (CompressedTexelFormat) String ```go @@ -2134,12 +4354,106 @@ type CompressedTexelFormat_AMD_compressed_ATC_texture uint32 enum CompressedTexelFormat_AMD_compressed_ATC_texture ////////////////////////////////////////////////////////////////////////////// +#### func (*CompressedTexelFormat_AMD_compressed_ATC_texture) Parse + +```go +func (v *CompressedTexelFormat_AMD_compressed_ATC_texture) Parse(s string) error +``` + #### func (CompressedTexelFormat_AMD_compressed_ATC_texture) String ```go func (v CompressedTexelFormat_AMD_compressed_ATC_texture) String() string ``` +#### type CompressedTexelFormat_EXT_texture_compression_dxt1 + +```go +type CompressedTexelFormat_EXT_texture_compression_dxt1 uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum CompressedTexelFormat_EXT_texture_compression_dxt1 +////////////////////////////////////////////////////////////////////////////// + +#### func (*CompressedTexelFormat_EXT_texture_compression_dxt1) Parse + +```go +func (v *CompressedTexelFormat_EXT_texture_compression_dxt1) Parse(s string) error +``` + +#### func (CompressedTexelFormat_EXT_texture_compression_dxt1) String + +```go +func (v CompressedTexelFormat_EXT_texture_compression_dxt1) String() string +``` + +#### type CompressedTexelFormat_EXT_texture_compression_s3tc + +```go +type CompressedTexelFormat_EXT_texture_compression_s3tc uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum CompressedTexelFormat_EXT_texture_compression_s3tc +////////////////////////////////////////////////////////////////////////////// + +#### func (*CompressedTexelFormat_EXT_texture_compression_s3tc) Parse + +```go +func (v *CompressedTexelFormat_EXT_texture_compression_s3tc) Parse(s string) error +``` + +#### func (CompressedTexelFormat_EXT_texture_compression_s3tc) String + +```go +func (v CompressedTexelFormat_EXT_texture_compression_s3tc) String() string +``` + +#### type CompressedTexelFormat_KHR_texture_compression_astc_ldr + +```go +type CompressedTexelFormat_KHR_texture_compression_astc_ldr uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum CompressedTexelFormat_KHR_texture_compression_astc_ldr +////////////////////////////////////////////////////////////////////////////// + +#### func (*CompressedTexelFormat_KHR_texture_compression_astc_ldr) Parse + +```go +func (v *CompressedTexelFormat_KHR_texture_compression_astc_ldr) Parse(s string) error +``` + +#### func (CompressedTexelFormat_KHR_texture_compression_astc_ldr) String + +```go +func (v CompressedTexelFormat_KHR_texture_compression_astc_ldr) String() string +``` + +#### type CompressedTexelFormat_NV_texture_compression_latc + +```go +type CompressedTexelFormat_NV_texture_compression_latc uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum CompressedTexelFormat_NV_texture_compression_latc +////////////////////////////////////////////////////////////////////////////// + +#### func (*CompressedTexelFormat_NV_texture_compression_latc) Parse + +```go +func (v *CompressedTexelFormat_NV_texture_compression_latc) Parse(s string) error +``` + +#### func (CompressedTexelFormat_NV_texture_compression_latc) String + +```go +func (v CompressedTexelFormat_NV_texture_compression_latc) String() string +``` + #### type CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture ```go @@ -2150,6 +4464,12 @@ type CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture uint32 enum CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture ////////////////////////////////////////////////////////////////////////////// +#### func (*CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture) Parse + +```go +func (v *CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture) Parse(s string) error +``` + #### func (CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture) String ```go @@ -2166,17 +4486,17 @@ type Context struct { Blending BlendState Rasterizing RasterizerState Clearing ClearState - BoundFramebuffers FramebufferId_FramebufferTargetMap - BoundRenderbuffers RenderbufferId_RenderbufferTargetMap - BoundBuffers BufferId_BufferTargetMap + BoundFramebuffers FramebufferTargetːFramebufferIdᵐ + BoundRenderbuffers RenderbufferTargetːRenderbufferIdᵐ + BoundBuffers BufferTargetːBufferIdᵐ BoundProgram ProgramId BoundVertexArray VertexArrayId - VertexAttributeArrays VertexAttributeArrayPtr_AttributeLocationMap - TextureUnits TextureId_TextureTargetMap_TextureUnitMap + VertexAttributeArrays AttributeLocationːVertexAttributeArrayʳᵐ + TextureUnits TextureUnitːTextureTargetːTextureIdᵐᵐ ActiveTextureUnit TextureUnit - Capabilities Bool_CapabilityMap + Capabilities Capabilityːboolᵐ GenerateMipmapHint HintMode - PixelStorage S32_PixelStoreParameterMap + PixelStorage PixelStoreParameterːs32ᵐ Instances Objects } ``` @@ -2203,471 +4523,752 @@ func (c *Context) GetCreatedAt() atom.ID func (c *Context) Init() ``` -#### type ContextArray +#### type ContextID ```go -type ContextArray []Context +type ContextID uint32 ``` -#### func (ContextArray) Len +#### type CubeMapImageTarget ```go -func (s ContextArray) Len() int +type CubeMapImageTarget uint32 ``` -#### func (ContextArray) Range +////////////////////////////////////////////////////////////////////////////// +enum CubeMapImageTarget +////////////////////////////////////////////////////////////////////////////// + +#### func (*CubeMapImageTarget) Parse ```go -func (s ContextArray) Range() []Context +func (v *CubeMapImageTarget) Parse(s string) error ``` -#### type ContextID +#### func (CubeMapImageTarget) String ```go -type ContextID uint32 +func (v CubeMapImageTarget) String() string +``` + +#### type CubeMapImageTargetːImageᵐ + +```go +type CubeMapImageTargetːImageᵐ map[CubeMapImageTarget]Image +``` + + +#### func (CubeMapImageTargetːImageᵐ) Contains + +```go +func (m CubeMapImageTargetːImageᵐ) Contains(key CubeMapImageTarget) bool ``` +#### func (CubeMapImageTargetːImageᵐ) Delete -#### func (*ContextID) Equal +```go +func (m CubeMapImageTargetːImageᵐ) Delete(key CubeMapImageTarget) +``` + +#### func (CubeMapImageTargetːImageᵐ) Get ```go -func (c *ContextID) Equal(rhs ContextID) bool +func (m CubeMapImageTargetːImageᵐ) Get(key CubeMapImageTarget) Image ``` -#### func (*ContextID) Less +#### func (CubeMapImageTargetːImageᵐ) Range ```go -func (c *ContextID) Less(rhs ContextID) bool +func (m CubeMapImageTargetːImageᵐ) Range() []Image ``` -#### type ContextPtr_CGLContextObjMap +#### type CubemapLevel + +```go +type CubemapLevel struct { + binary.Generate + CreatedAt atom.ID + Faces CubeMapImageTargetːImageᵐ +} +``` + +////////////////////////////////////////////////////////////////////////////// +class CubemapLevel +////////////////////////////////////////////////////////////////////////////// + +#### func (*CubemapLevel) Class ```go -type ContextPtr_CGLContextObjMap map[CGLContextObj]*Context +func (*CubemapLevel) Class() binary.Class ``` +#### func (*CubemapLevel) GetCreatedAt -#### func (ContextPtr_CGLContextObjMap) Contains +```go +func (c *CubemapLevel) GetCreatedAt() atom.ID +``` + +#### func (*CubemapLevel) Init ```go -func (m ContextPtr_CGLContextObjMap) Contains(key CGLContextObj) bool +func (c *CubemapLevel) Init() ``` -#### func (ContextPtr_CGLContextObjMap) Delete +#### type DiscardFramebufferAttachment ```go -func (m ContextPtr_CGLContextObjMap) Delete(key CGLContextObj) +type DiscardFramebufferAttachment uint32 ``` -#### func (ContextPtr_CGLContextObjMap) Get +////////////////////////////////////////////////////////////////////////////// +enum DiscardFramebufferAttachment +////////////////////////////////////////////////////////////////////////////// + +#### func (*DiscardFramebufferAttachment) Parse ```go -func (m ContextPtr_CGLContextObjMap) Get(key CGLContextObj) *Context +func (v *DiscardFramebufferAttachment) Parse(s string) error ``` -#### func (ContextPtr_CGLContextObjMap) Range +#### func (DiscardFramebufferAttachment) String ```go -func (m ContextPtr_CGLContextObjMap) Range() []*Context +func (v DiscardFramebufferAttachment) String() string ``` -#### type ContextPtr_EGLContextMap +#### type DiscardFramebufferAttachmentˢ ```go -type ContextPtr_EGLContextMap map[EGLContext]*Context +type DiscardFramebufferAttachmentˢ struct { + binary.Generate + SliceInfo +} ``` +DiscardFramebufferAttachmentˢ is a slice of DiscardFramebufferAttachment. -#### func (ContextPtr_EGLContextMap) Contains +#### func AsDiscardFramebufferAttachmentˢ ```go -func (m ContextPtr_EGLContextMap) Contains(key EGLContext) bool +func AsDiscardFramebufferAttachmentˢ(s Slice, ϟs *gfxapi.State) DiscardFramebufferAttachmentˢ ``` +AsDiscardFramebufferAttachmentˢ returns s cast to a +DiscardFramebufferAttachmentˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. -#### func (ContextPtr_EGLContextMap) Delete +#### func MakeDiscardFramebufferAttachmentˢ ```go -func (m ContextPtr_EGLContextMap) Delete(key EGLContext) +func MakeDiscardFramebufferAttachmentˢ(count uint64, ϟs *gfxapi.State) DiscardFramebufferAttachmentˢ ``` +MakeDiscardFramebufferAttachmentˢ returns a DiscardFramebufferAttachmentˢ backed +by a new memory pool. -#### func (ContextPtr_EGLContextMap) Get +#### func (*DiscardFramebufferAttachmentˢ) Class ```go -func (m ContextPtr_EGLContextMap) Get(key EGLContext) *Context +func (*DiscardFramebufferAttachmentˢ) Class() binary.Class ``` -#### func (ContextPtr_EGLContextMap) Range +#### func (DiscardFramebufferAttachmentˢ) Clone ```go -func (m ContextPtr_EGLContextMap) Range() []*Context +func (s DiscardFramebufferAttachmentˢ) Clone(ϟs *gfxapi.State) DiscardFramebufferAttachmentˢ ``` +Clone returns a copy of the DiscardFramebufferAttachmentˢ in a new memory pool. -#### type ContextPtr_GLXContextMap +#### func (DiscardFramebufferAttachmentˢ) Copy ```go -type ContextPtr_GLXContextMap map[GLXContext]*Context +func (dst DiscardFramebufferAttachmentˢ) Copy(src DiscardFramebufferAttachmentˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s DiscardFramebufferAttachmentˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. +#### func (DiscardFramebufferAttachmentˢ) Decoder -#### func (ContextPtr_GLXContextMap) Contains +```go +func (s DiscardFramebufferAttachmentˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (DiscardFramebufferAttachmentˢ) ElementSize ```go -func (m ContextPtr_GLXContextMap) Contains(key GLXContext) bool +func (s DiscardFramebufferAttachmentˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that +DiscardFramebufferAttachmentˢ points to. -#### func (ContextPtr_GLXContextMap) Delete +#### func (DiscardFramebufferAttachmentˢ) Encoder ```go -func (m ContextPtr_GLXContextMap) Delete(key GLXContext) +func (s DiscardFramebufferAttachmentˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (ContextPtr_GLXContextMap) Get +#### func (DiscardFramebufferAttachmentˢ) Index ```go -func (m ContextPtr_GLXContextMap) Get(key GLXContext) *Context +func (s DiscardFramebufferAttachmentˢ) Index(i uint64, ϟs *gfxapi.State) DiscardFramebufferAttachmentᵖ ``` +Index returns a DiscardFramebufferAttachmentᵖ to the i'th element in this +DiscardFramebufferAttachmentˢ. -#### func (ContextPtr_GLXContextMap) Range +#### func (DiscardFramebufferAttachmentˢ) Range ```go -func (m ContextPtr_GLXContextMap) Range() []*Context +func (s DiscardFramebufferAttachmentˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### type ContextPtr_HGLRCMap +#### func (DiscardFramebufferAttachmentˢ) Read ```go -type ContextPtr_HGLRCMap map[HGLRC]*Context +func (s DiscardFramebufferAttachmentˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []DiscardFramebufferAttachment ``` +Read reads and returns all the DiscardFramebufferAttachment elements in this +DiscardFramebufferAttachmentˢ. +#### func (DiscardFramebufferAttachmentˢ) ResourceID -#### func (ContextPtr_HGLRCMap) Contains +```go +func (s DiscardFramebufferAttachmentˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (DiscardFramebufferAttachmentˢ) Slice ```go -func (m ContextPtr_HGLRCMap) Contains(key HGLRC) bool +func (s DiscardFramebufferAttachmentˢ) Slice(start, end uint64, ϟs *gfxapi.State) DiscardFramebufferAttachmentˢ ``` +Slice returns a sub-slice from the DiscardFramebufferAttachmentˢ using start and +end indices. -#### func (ContextPtr_HGLRCMap) Delete +#### func (DiscardFramebufferAttachmentˢ) String ```go -func (m ContextPtr_HGLRCMap) Delete(key HGLRC) +func (s DiscardFramebufferAttachmentˢ) String() string ``` +String returns a string description of the DiscardFramebufferAttachmentˢ slice. -#### func (ContextPtr_HGLRCMap) Get +#### func (DiscardFramebufferAttachmentˢ) Write ```go -func (m ContextPtr_HGLRCMap) Get(key HGLRC) *Context +func (dst DiscardFramebufferAttachmentˢ) Write(src []DiscardFramebufferAttachment, ϟs *gfxapi.State) uint64 ``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### func (ContextPtr_HGLRCMap) Range +#### type DiscardFramebufferAttachmentᵖ ```go -func (m ContextPtr_HGLRCMap) Range() []*Context +type DiscardFramebufferAttachmentᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### type ContextPtr_ThreadIDMap +DiscardFramebufferAttachmentᵖ is a pointer to a DiscardFramebufferAttachment +element. + +#### func NewDiscardFramebufferAttachmentᵖ ```go -type ContextPtr_ThreadIDMap map[ThreadID]*Context +func NewDiscardFramebufferAttachmentᵖ(addr memory.Pointer) DiscardFramebufferAttachmentᵖ ``` +NewDiscardFramebufferAttachmentᵖ returns a DiscardFramebufferAttachmentᵖ that +points to addr in the application pool. + +#### func (*DiscardFramebufferAttachmentᵖ) Class +```go +func (*DiscardFramebufferAttachmentᵖ) Class() binary.Class +``` -#### func (ContextPtr_ThreadIDMap) Contains +#### func (DiscardFramebufferAttachmentᵖ) ElementSize ```go -func (m ContextPtr_ThreadIDMap) Contains(key ThreadID) bool +func (p DiscardFramebufferAttachmentᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that +DiscardFramebufferAttachmentᵖ points to. -#### func (ContextPtr_ThreadIDMap) Delete +#### func (DiscardFramebufferAttachmentᵖ) Read ```go -func (m ContextPtr_ThreadIDMap) Delete(key ThreadID) +func (p DiscardFramebufferAttachmentᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) DiscardFramebufferAttachment ``` +Read reads and returns the DiscardFramebufferAttachment element at the pointer. -#### func (ContextPtr_ThreadIDMap) Get +#### func (DiscardFramebufferAttachmentᵖ) Slice ```go -func (m ContextPtr_ThreadIDMap) Get(key ThreadID) *Context +func (p DiscardFramebufferAttachmentᵖ) Slice(start, end uint64, ϟs *gfxapi.State) DiscardFramebufferAttachmentˢ ``` +Slice returns a new DiscardFramebufferAttachmentˢ from the pointer using start +and end indices. -#### func (ContextPtr_ThreadIDMap) Range +#### func (DiscardFramebufferAttachmentᵖ) String ```go -func (m ContextPtr_ThreadIDMap) Range() []*Context +func (p DiscardFramebufferAttachmentᵖ) String() string ``` +String returns a string description of the DiscardFramebufferAttachmentᵖ +pointer. -#### type CubeMapImageTarget +#### func (DiscardFramebufferAttachmentᵖ) Write ```go -type CubeMapImageTarget uint32 +func (p DiscardFramebufferAttachmentᵖ) Write(value DiscardFramebufferAttachment, ϟs *gfxapi.State) +``` +Write writes value to the DiscardFramebufferAttachment element at the pointer. + +#### type DrawMode + +```go +type DrawMode uint32 ``` ////////////////////////////////////////////////////////////////////////////// -enum CubeMapImageTarget +enum DrawMode ////////////////////////////////////////////////////////////////////////////// -#### func (CubeMapImageTarget) String +#### func (*DrawMode) Parse ```go -func (v CubeMapImageTarget) String() string +func (v *DrawMode) Parse(s string) error ``` -#### type CubemapLevel +#### func (DrawMode) String ```go -type CubemapLevel struct { +func (v DrawMode) String() string +``` + +#### type EGLBoolean + +```go +type EGLBoolean int64 +``` + + +#### type EGLConfig + +```go +type EGLConfig struct { binary.Generate - CreatedAt atom.ID - Faces Image_CubeMapImageTargetMap + Address memory.Pointer + Pool memory.PoolID } ``` -////////////////////////////////////////////////////////////////////////////// -class CubemapLevel -////////////////////////////////////////////////////////////////////////////// +EGLConfig is a pointer to a void element. -#### func (*CubemapLevel) Class +#### func NewEGLConfig ```go -func (*CubemapLevel) Class() binary.Class +func NewEGLConfig(addr memory.Pointer) EGLConfig ``` +NewEGLConfig returns a EGLConfig that points to addr in the application pool. -#### func (*CubemapLevel) GetCreatedAt +#### func (*EGLConfig) Class ```go -func (c *CubemapLevel) GetCreatedAt() atom.ID +func (*EGLConfig) Class() binary.Class ``` -#### func (*CubemapLevel) Init +#### func (EGLConfig) ElementSize ```go -func (c *CubemapLevel) Init() +func (p EGLConfig) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that EGLConfig points to. -#### type CubemapLevel_s32Map +#### func (EGLConfig) Slice ```go -type CubemapLevel_s32Map map[int32]CubemapLevel +func (p EGLConfig) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. +#### func (EGLConfig) String -#### func (CubemapLevel_s32Map) Contains +```go +func (p EGLConfig) String() string +``` +String returns a string description of the EGLConfig pointer. + +#### type EGLContext ```go -func (m CubemapLevel_s32Map) Contains(key int32) bool +type EGLContext struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (CubemapLevel_s32Map) Delete +EGLContext is a pointer to a void element. + +#### func NewEGLContext ```go -func (m CubemapLevel_s32Map) Delete(key int32) +func NewEGLContext(addr memory.Pointer) EGLContext ``` +NewEGLContext returns a EGLContext that points to addr in the application pool. -#### func (CubemapLevel_s32Map) Get +#### func (*EGLContext) Class ```go -func (m CubemapLevel_s32Map) Get(key int32) CubemapLevel +func (*EGLContext) Class() binary.Class ``` -#### func (CubemapLevel_s32Map) Range +#### func (EGLContext) ElementSize ```go -func (m CubemapLevel_s32Map) Range() []CubemapLevel +func (p EGLContext) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that EGLContext points to. -#### type DiscardFramebufferAttachment +#### func (EGLContext) Slice ```go -type DiscardFramebufferAttachment uint32 +func (p EGLContext) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. -////////////////////////////////////////////////////////////////////////////// -enum DiscardFramebufferAttachment -////////////////////////////////////////////////////////////////////////////// +#### func (EGLContext) String -#### func (DiscardFramebufferAttachment) String +```go +func (p EGLContext) String() string +``` +String returns a string description of the EGLContext pointer. + +#### type EGLContextːContextʳᵐ ```go -func (v DiscardFramebufferAttachment) String() string +type EGLContextːContextʳᵐ map[EGLContext](*Context) ``` -#### type DiscardFramebufferAttachmentArray + +#### func (EGLContextːContextʳᵐ) Contains ```go -type DiscardFramebufferAttachmentArray []DiscardFramebufferAttachment +func (m EGLContextːContextʳᵐ) Contains(key EGLContext) bool ``` +#### func (EGLContextːContextʳᵐ) Delete -#### func (DiscardFramebufferAttachmentArray) Len +```go +func (m EGLContextːContextʳᵐ) Delete(key EGLContext) +``` + +#### func (EGLContextːContextʳᵐ) Get ```go -func (s DiscardFramebufferAttachmentArray) Len() int +func (m EGLContextːContextʳᵐ) Get(key EGLContext) *Context ``` -#### func (DiscardFramebufferAttachmentArray) Range +#### func (EGLContextːContextʳᵐ) Range ```go -func (s DiscardFramebufferAttachmentArray) Range() []DiscardFramebufferAttachment +func (m EGLContextːContextʳᵐ) Range() [](*Context) ``` -#### type DrawMode +#### type EGLDisplay ```go -type DrawMode uint32 +type EGLDisplay struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -////////////////////////////////////////////////////////////////////////////// -enum DrawMode -////////////////////////////////////////////////////////////////////////////// +EGLDisplay is a pointer to a void element. -#### func (DrawMode) String +#### func NewEGLDisplay ```go -func (v DrawMode) String() string +func NewEGLDisplay(addr memory.Pointer) EGLDisplay ``` +NewEGLDisplay returns a EGLDisplay that points to addr in the application pool. -#### type EGLBoolean +#### func (*EGLDisplay) Class ```go -type EGLBoolean int64 +func (*EGLDisplay) Class() binary.Class ``` +#### func (EGLDisplay) ElementSize -#### func (*EGLBoolean) Equal +```go +func (p EGLDisplay) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that EGLDisplay points to. + +#### func (EGLDisplay) Slice ```go -func (c *EGLBoolean) Equal(rhs EGLBoolean) bool +func (p EGLDisplay) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (*EGLBoolean) Less +#### func (EGLDisplay) String ```go -func (c *EGLBoolean) Less(rhs EGLBoolean) bool +func (p EGLDisplay) String() string ``` +String returns a string description of the EGLDisplay pointer. -#### type EGLConfig +#### type EGLSurface ```go -type EGLConfig memory.Pointer +type EGLSurface struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +EGLSurface is a pointer to a void element. -#### func (*EGLConfig) Equal +#### func NewEGLSurface ```go -func (c *EGLConfig) Equal(rhs EGLConfig) bool +func NewEGLSurface(addr memory.Pointer) EGLSurface ``` +NewEGLSurface returns a EGLSurface that points to addr in the application pool. -#### func (*EGLConfig) Less +#### func (*EGLSurface) Class ```go -func (c *EGLConfig) Less(rhs EGLConfig) bool +func (*EGLSurface) Class() binary.Class ``` -#### type EGLContext +#### func (EGLSurface) ElementSize ```go -type EGLContext memory.Pointer +func (p EGLSurface) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that EGLSurface points to. + +#### func (EGLSurface) Slice +```go +func (p EGLSurface) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (*EGLContext) Equal +#### func (EGLSurface) String ```go -func (c *EGLContext) Equal(rhs EGLContext) bool +func (p EGLSurface) String() string ``` +String returns a string description of the EGLSurface pointer. -#### func (*EGLContext) Less +#### type EGLint ```go -func (c *EGLContext) Less(rhs EGLContext) bool +type EGLint int64 ``` -#### type EGLDisplay + +#### type EGLintˢ ```go -type EGLDisplay memory.Pointer +type EGLintˢ struct { + binary.Generate + SliceInfo +} ``` +EGLintˢ is a slice of EGLint. -#### func (*EGLDisplay) Equal +#### func AsEGLintˢ ```go -func (c *EGLDisplay) Equal(rhs EGLDisplay) bool +func AsEGLintˢ(s Slice, ϟs *gfxapi.State) EGLintˢ ``` +AsEGLintˢ returns s cast to a EGLintˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### func (*EGLDisplay) Less +#### func MakeEGLintˢ ```go -func (c *EGLDisplay) Less(rhs EGLDisplay) bool +func MakeEGLintˢ(count uint64, ϟs *gfxapi.State) EGLintˢ ``` +MakeEGLintˢ returns a EGLintˢ backed by a new memory pool. -#### type EGLSurface +#### func (*EGLintˢ) Class + +```go +func (*EGLintˢ) Class() binary.Class +``` + +#### func (EGLintˢ) Clone ```go -type EGLSurface memory.Pointer +func (s EGLintˢ) Clone(ϟs *gfxapi.State) EGLintˢ ``` +Clone returns a copy of the EGLintˢ in a new memory pool. +#### func (EGLintˢ) Copy -#### func (*EGLSurface) Equal +```go +func (dst EGLintˢ) Copy(src EGLintˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s EGLintˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (EGLintˢ) Decoder ```go -func (c *EGLSurface) Equal(rhs EGLSurface) bool +func (s EGLintˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (*EGLSurface) Less +#### func (EGLintˢ) ElementSize ```go -func (c *EGLSurface) Less(rhs EGLSurface) bool +func (s EGLintˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that EGLintˢ points to. -#### type EGLint +#### func (EGLintˢ) Encoder ```go -type EGLint int64 +func (s EGLintˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (EGLintˢ) Index + +```go +func (s EGLintˢ) Index(i uint64, ϟs *gfxapi.State) EGLintᵖ +``` +Index returns a EGLintᵖ to the i'th element in this EGLintˢ. + +#### func (EGLintˢ) Range + +```go +func (s EGLintˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (EGLintˢ) Read + +```go +func (s EGLintˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []EGLint ``` +Read reads and returns all the EGLint elements in this EGLintˢ. +#### func (EGLintˢ) ResourceID + +```go +func (s EGLintˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (EGLintˢ) Slice + +```go +func (s EGLintˢ) Slice(start, end uint64, ϟs *gfxapi.State) EGLintˢ +``` +Slice returns a sub-slice from the EGLintˢ using start and end indices. -#### func (*EGLint) Equal +#### func (EGLintˢ) String ```go -func (c *EGLint) Equal(rhs EGLint) bool +func (s EGLintˢ) String() string ``` +String returns a string description of the EGLintˢ slice. -#### func (*EGLint) Less +#### func (EGLintˢ) Write ```go -func (c *EGLint) Less(rhs EGLint) bool +func (dst EGLintˢ) Write(src []EGLint, ϟs *gfxapi.State) uint64 ``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### type EGLintArray +#### type EGLintᵖ ```go -type EGLintArray []EGLint +type EGLintᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +EGLintᵖ is a pointer to a EGLint element. -#### func (EGLintArray) Len +#### func NewEGLintᵖ ```go -func (s EGLintArray) Len() int +func NewEGLintᵖ(addr memory.Pointer) EGLintᵖ ``` +NewEGLintᵖ returns a EGLintᵖ that points to addr in the application pool. -#### func (EGLintArray) Range +#### func (*EGLintᵖ) Class ```go -func (s EGLintArray) Range() []EGLint +func (*EGLintᵖ) Class() binary.Class ``` +#### func (EGLintᵖ) ElementSize + +```go +func (p EGLintᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that EGLintᵖ points to. + +#### func (EGLintᵖ) Read + +```go +func (p EGLintᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) EGLint +``` +Read reads and returns the EGLint element at the pointer. + +#### func (EGLintᵖ) Slice + +```go +func (p EGLintᵖ) Slice(start, end uint64, ϟs *gfxapi.State) EGLintˢ +``` +Slice returns a new EGLintˢ from the pointer using start and end indices. + +#### func (EGLintᵖ) String + +```go +func (p EGLintᵖ) String() string +``` +String returns a string description of the EGLintᵖ pointer. + +#### func (EGLintᵖ) Write + +```go +func (p EGLintᵖ) Write(value EGLint, ϟs *gfxapi.State) +``` +Write writes value to the EGLint element at the pointer. + #### type EglCreateContext ```go type EglCreateContext struct { binary.Generate + Display EGLDisplay Config EGLConfig ShareContext EGLContext - AttribList EGLintArray + AttribList EGLintᵖ Result EGLContext } ``` @@ -2679,13 +5280,7 @@ EglCreateContext #### func NewEglCreateContext ```go -func NewEglCreateContext( - pDisplay EGLDisplay, - pConfig EGLConfig, - pShareContext EGLContext, - pAttribList EGLintArray, - pResult EGLContext, -) *EglCreateContext +func NewEglCreateContext(Display memory.Pointer, Config memory.Pointer, Share_context memory.Pointer, Attrib_list memory.Pointer, Result memory.Pointer) *EglCreateContext ``` #### func (*EglCreateContext) API @@ -2694,55 +5289,62 @@ func NewEglCreateContext( func (c *EglCreateContext) API() gfxapi.API ``` -#### func (*EglCreateContext) Class +#### func (*EglCreateContext) AddRead ```go -func (*EglCreateContext) Class() binary.Class +func (a *EglCreateContext) AddRead(rng memory.Range, id binary.ID) *EglCreateContext ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The EglCreateContext pointer is returned so that calls can be chained. -#### func (*EglCreateContext) Flags +#### func (*EglCreateContext) AddWrite ```go -func (c *EglCreateContext) Flags() atom.Flags +func (a *EglCreateContext) AddWrite(rng memory.Range, id binary.ID) *EglCreateContext ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The EglCreateContext pointer is returned so that calls can be chained. -#### func (*EglCreateContext) Mutate +#### func (*EglCreateContext) Class ```go -func (ϟa *EglCreateContext) Mutate(ϟs *gfxapi.State) error +func (*EglCreateContext) Class() binary.Class ``` -#### func (*EglCreateContext) Replay +#### func (*EglCreateContext) Flags ```go -func (ω *EglCreateContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (c *EglCreateContext) Flags() atom.Flags ``` -#### func (*EglCreateContext) String +#### func (*EglCreateContext) Mutate ```go -func (c *EglCreateContext) String() string +func (ϟa *EglCreateContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*EglCreateContext) TypeID +#### func (*EglCreateContext) Observations ```go -func (c *EglCreateContext) TypeID() atom.TypeID +func (a *EglCreateContext) Observations() *atom.Observations ``` -#### type EglCreateContext_Postback +#### func (*EglCreateContext) Replay ```go -type EglCreateContext_Postback struct { - Result []byte -} +func (ω *EglCreateContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` +#### func (*EglCreateContext) String + +```go +func (a *EglCreateContext) String() string +``` -#### func (*EglCreateContext_Postback) Decode +#### func (*EglCreateContext) TypeID ```go -func (o *EglCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *EglCreateContext) TypeID() atom.TypeID ``` #### type EglInitialize @@ -2750,9 +5352,10 @@ func (o *EglCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) ```go type EglInitialize struct { binary.Generate + Dpy EGLDisplay - Major EGLint - Minor EGLint + Major EGLintᵖ + Minor EGLintᵖ Result EGLBoolean } ``` @@ -2764,12 +5367,7 @@ EglInitialize #### func NewEglInitialize ```go -func NewEglInitialize( - pDpy EGLDisplay, - pMajor EGLint, - pMinor EGLint, - pResult EGLBoolean, -) *EglInitialize +func NewEglInitialize(Dpy memory.Pointer, Major memory.Pointer, Minor memory.Pointer, Result EGLBoolean) *EglInitialize ``` #### func (*EglInitialize) API @@ -2778,51 +5376,56 @@ func NewEglInitialize( func (c *EglInitialize) API() gfxapi.API ``` -#### func (*EglInitialize) Class +#### func (*EglInitialize) AddRead ```go -func (*EglInitialize) Class() binary.Class +func (a *EglInitialize) AddRead(rng memory.Range, id binary.ID) *EglInitialize ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The EglInitialize pointer is returned so that calls can be chained. -#### func (*EglInitialize) Flags +#### func (*EglInitialize) AddWrite ```go -func (c *EglInitialize) Flags() atom.Flags +func (a *EglInitialize) AddWrite(rng memory.Range, id binary.ID) *EglInitialize ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The EglInitialize pointer is returned so that calls can be chained. -#### func (*EglInitialize) Mutate +#### func (*EglInitialize) Class ```go -func (ϟa *EglInitialize) Mutate(ϟs *gfxapi.State) error +func (*EglInitialize) Class() binary.Class ``` -#### func (*EglInitialize) String +#### func (*EglInitialize) Flags ```go -func (c *EglInitialize) String() string +func (c *EglInitialize) Flags() atom.Flags ``` -#### func (*EglInitialize) TypeID +#### func (*EglInitialize) Mutate ```go -func (c *EglInitialize) TypeID() atom.TypeID +func (ϟa *EglInitialize) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type EglInitialize_Postback +#### func (*EglInitialize) Observations ```go -type EglInitialize_Postback struct { - Major EGLint - Minor EGLint - Result EGLBoolean -} +func (a *EglInitialize) Observations() *atom.Observations ``` +#### func (*EglInitialize) String -#### func (*EglInitialize_Postback) Decode +```go +func (a *EglInitialize) String() string +``` + +#### func (*EglInitialize) TypeID ```go -func (o *EglInitialize_Postback) Decode(d binary.Decoder) error +func (c *EglInitialize) TypeID() atom.TypeID ``` #### type EglMakeCurrent @@ -2830,6 +5433,7 @@ func (o *EglInitialize_Postback) Decode(d binary.Decoder) error ```go type EglMakeCurrent struct { binary.Generate + Display EGLDisplay Draw EGLSurface Read EGLSurface @@ -2845,13 +5449,7 @@ EglMakeCurrent #### func NewEglMakeCurrent ```go -func NewEglMakeCurrent( - pDisplay EGLDisplay, - pDraw EGLSurface, - pRead EGLSurface, - pContext EGLContext, - pResult EGLBoolean, -) *EglMakeCurrent +func NewEglMakeCurrent(Display memory.Pointer, Draw memory.Pointer, Read memory.Pointer, Context memory.Pointer, Result EGLBoolean) *EglMakeCurrent ``` #### func (*EglMakeCurrent) API @@ -2860,55 +5458,62 @@ func NewEglMakeCurrent( func (c *EglMakeCurrent) API() gfxapi.API ``` -#### func (*EglMakeCurrent) Class +#### func (*EglMakeCurrent) AddRead ```go -func (*EglMakeCurrent) Class() binary.Class +func (a *EglMakeCurrent) AddRead(rng memory.Range, id binary.ID) *EglMakeCurrent ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The EglMakeCurrent pointer is returned so that calls can be chained. -#### func (*EglMakeCurrent) Flags +#### func (*EglMakeCurrent) AddWrite ```go -func (c *EglMakeCurrent) Flags() atom.Flags +func (a *EglMakeCurrent) AddWrite(rng memory.Range, id binary.ID) *EglMakeCurrent ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The EglMakeCurrent pointer is returned so that calls can be chained. -#### func (*EglMakeCurrent) Mutate +#### func (*EglMakeCurrent) Class ```go -func (ϟa *EglMakeCurrent) Mutate(ϟs *gfxapi.State) error +func (*EglMakeCurrent) Class() binary.Class ``` -#### func (*EglMakeCurrent) Replay +#### func (*EglMakeCurrent) Flags ```go -func (ω *EglMakeCurrent) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (c *EglMakeCurrent) Flags() atom.Flags ``` -#### func (*EglMakeCurrent) String +#### func (*EglMakeCurrent) Mutate ```go -func (c *EglMakeCurrent) String() string +func (ϟa *EglMakeCurrent) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*EglMakeCurrent) TypeID +#### func (*EglMakeCurrent) Observations ```go -func (c *EglMakeCurrent) TypeID() atom.TypeID +func (a *EglMakeCurrent) Observations() *atom.Observations ``` -#### type EglMakeCurrent_Postback +#### func (*EglMakeCurrent) Replay ```go -type EglMakeCurrent_Postback struct { - Result EGLBoolean -} +func (ω *EglMakeCurrent) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` +#### func (*EglMakeCurrent) String -#### func (*EglMakeCurrent_Postback) Decode +```go +func (a *EglMakeCurrent) String() string +``` + +#### func (*EglMakeCurrent) TypeID ```go -func (o *EglMakeCurrent_Postback) Decode(d binary.Decoder) error +func (c *EglMakeCurrent) TypeID() atom.TypeID ``` #### type EglQuerySurface @@ -2916,10 +5521,11 @@ func (o *EglMakeCurrent_Postback) Decode(d binary.Decoder) error ```go type EglQuerySurface struct { binary.Generate + Display EGLDisplay Surface EGLSurface Attribute EGLint - Value EGLint + Value EGLintᵖ Result EGLBoolean } ``` @@ -2931,13 +5537,7 @@ EglQuerySurface #### func NewEglQuerySurface ```go -func NewEglQuerySurface( - pDisplay EGLDisplay, - pSurface EGLSurface, - pAttribute EGLint, - pValue EGLint, - pResult EGLBoolean, -) *EglQuerySurface +func NewEglQuerySurface(Display memory.Pointer, Surface memory.Pointer, Attribute EGLint, Value memory.Pointer, Result EGLBoolean) *EglQuerySurface ``` #### func (*EglQuerySurface) API @@ -2946,50 +5546,56 @@ func NewEglQuerySurface( func (c *EglQuerySurface) API() gfxapi.API ``` -#### func (*EglQuerySurface) Class +#### func (*EglQuerySurface) AddRead ```go -func (*EglQuerySurface) Class() binary.Class +func (a *EglQuerySurface) AddRead(rng memory.Range, id binary.ID) *EglQuerySurface ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The EglQuerySurface pointer is returned so that calls can be chained. -#### func (*EglQuerySurface) Flags +#### func (*EglQuerySurface) AddWrite ```go -func (c *EglQuerySurface) Flags() atom.Flags +func (a *EglQuerySurface) AddWrite(rng memory.Range, id binary.ID) *EglQuerySurface ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The EglQuerySurface pointer is returned so that calls can be chained. -#### func (*EglQuerySurface) Mutate +#### func (*EglQuerySurface) Class ```go -func (ϟa *EglQuerySurface) Mutate(ϟs *gfxapi.State) error +func (*EglQuerySurface) Class() binary.Class ``` -#### func (*EglQuerySurface) String +#### func (*EglQuerySurface) Flags ```go -func (c *EglQuerySurface) String() string +func (c *EglQuerySurface) Flags() atom.Flags ``` -#### func (*EglQuerySurface) TypeID +#### func (*EglQuerySurface) Mutate ```go -func (c *EglQuerySurface) TypeID() atom.TypeID +func (ϟa *EglQuerySurface) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type EglQuerySurface_Postback +#### func (*EglQuerySurface) Observations ```go -type EglQuerySurface_Postback struct { - Value EGLint - Result EGLBoolean -} +func (a *EglQuerySurface) Observations() *atom.Observations ``` +#### func (*EglQuerySurface) String + +```go +func (a *EglQuerySurface) String() string +``` -#### func (*EglQuerySurface_Postback) Decode +#### func (*EglQuerySurface) TypeID ```go -func (o *EglQuerySurface_Postback) Decode(d binary.Decoder) error +func (c *EglQuerySurface) TypeID() atom.TypeID ``` #### type EglSwapBuffers @@ -2997,8 +5603,9 @@ func (o *EglQuerySurface_Postback) Decode(d binary.Decoder) error ```go type EglSwapBuffers struct { binary.Generate + Display EGLDisplay - Surface memory.Pointer + Surface Voidᵖ Result EGLBoolean } ``` @@ -3010,11 +5617,7 @@ EglSwapBuffers #### func NewEglSwapBuffers ```go -func NewEglSwapBuffers( - pDisplay EGLDisplay, - pSurface memory.Pointer, - pResult EGLBoolean, -) *EglSwapBuffers +func NewEglSwapBuffers(Display memory.Pointer, Surface memory.Pointer, Result EGLBoolean) *EglSwapBuffers ``` #### func (*EglSwapBuffers) API @@ -3023,6 +5626,22 @@ func NewEglSwapBuffers( func (c *EglSwapBuffers) API() gfxapi.API ``` +#### func (*EglSwapBuffers) AddRead + +```go +func (a *EglSwapBuffers) AddRead(rng memory.Range, id binary.ID) *EglSwapBuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The EglSwapBuffers pointer is returned so that calls can be chained. + +#### func (*EglSwapBuffers) AddWrite + +```go +func (a *EglSwapBuffers) AddWrite(rng memory.Range, id binary.ID) *EglSwapBuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The EglSwapBuffers pointer is returned so that calls can be chained. + #### func (*EglSwapBuffers) Class ```go @@ -3038,13 +5657,19 @@ func (c *EglSwapBuffers) Flags() atom.Flags #### func (*EglSwapBuffers) Mutate ```go -func (ϟa *EglSwapBuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *EglSwapBuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*EglSwapBuffers) Observations + +```go +func (a *EglSwapBuffers) Observations() *atom.Observations ``` #### func (*EglSwapBuffers) String ```go -func (c *EglSwapBuffers) String() string +func (a *EglSwapBuffers) String() string ``` #### func (*EglSwapBuffers) TypeID @@ -3053,55 +5678,435 @@ func (c *EglSwapBuffers) String() string func (c *EglSwapBuffers) TypeID() atom.TypeID ``` -#### type EglSwapBuffers_Postback +#### type Error ```go -type EglSwapBuffers_Postback struct { - Result EGLBoolean +type Error uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum Error +////////////////////////////////////////////////////////////////////////////// + +#### func (*Error) Parse + +```go +func (v *Error) Parse(s string) error +``` + +#### func (Error) String + +```go +func (v Error) String() string +``` + +#### type F32ː2ᵃ + +```go +type F32ː2ᵃ struct { + binary.Generate + Elements [2]float32 } ``` -#### func (*EglSwapBuffers_Postback) Decode +#### func (*F32ː2ᵃ) Class ```go -func (o *EglSwapBuffers_Postback) Decode(d binary.Decoder) error +func (*F32ː2ᵃ) Class() binary.Class ``` -#### type Error +#### type F32ː3ᵃ ```go -type Error uint32 +type F32ː3ᵃ struct { + binary.Generate + Elements [3]float32 +} ``` -////////////////////////////////////////////////////////////////////////////// -enum Error -////////////////////////////////////////////////////////////////////////////// -#### func (Error) String +#### func (*F32ː3ᵃ) Class ```go -func (v Error) String() string +func (*F32ː3ᵃ) Class() binary.Class +``` + +#### type F32ː4ᵃ + +```go +type F32ː4ᵃ struct { + binary.Generate + Elements [4]float32 +} +``` + + +#### func (*F32ː4ᵃ) Class + +```go +func (*F32ː4ᵃ) Class() binary.Class +``` + +#### type F32ˢ + +```go +type F32ˢ struct { + binary.Generate + SliceInfo +} +``` + +F32ˢ is a slice of float32. + +#### func AsF32ˢ + +```go +func AsF32ˢ(s Slice, ϟs *gfxapi.State) F32ˢ +``` +AsF32ˢ returns s cast to a F32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeF32ˢ + +```go +func MakeF32ˢ(count uint64, ϟs *gfxapi.State) F32ˢ +``` +MakeF32ˢ returns a F32ˢ backed by a new memory pool. + +#### func (*F32ˢ) Class + +```go +func (*F32ˢ) Class() binary.Class +``` + +#### func (F32ˢ) Clone + +```go +func (s F32ˢ) Clone(ϟs *gfxapi.State) F32ˢ +``` +Clone returns a copy of the F32ˢ in a new memory pool. + +#### func (F32ˢ) Copy + +```go +func (dst F32ˢ) Copy(src F32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s F32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (F32ˢ) Decoder + +```go +func (s F32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (F32ˢ) ElementSize + +```go +func (s F32ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F32ˢ points to. + +#### func (F32ˢ) Encoder + +```go +func (s F32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (F32ˢ) Index + +```go +func (s F32ˢ) Index(i uint64, ϟs *gfxapi.State) F32ᵖ +``` +Index returns a F32ᵖ to the i'th element in this F32ˢ. + +#### func (F32ˢ) Range + +```go +func (s F32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (F32ˢ) Read + +```go +func (s F32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []float32 +``` +Read reads and returns all the float32 elements in this F32ˢ. + +#### func (F32ˢ) ResourceID + +```go +func (s F32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (F32ˢ) Slice + +```go +func (s F32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) F32ˢ +``` +Slice returns a sub-slice from the F32ˢ using start and end indices. + +#### func (F32ˢ) String + +```go +func (s F32ˢ) String() string +``` +String returns a string description of the F32ˢ slice. + +#### func (F32ˢ) Write + +```go +func (dst F32ˢ) Write(src []float32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type F32ᵖ + +```go +type F32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +F32ᵖ is a pointer to a float32 element. + +#### func NewF32ᵖ + +```go +func NewF32ᵖ(addr memory.Pointer) F32ᵖ +``` +NewF32ᵖ returns a F32ᵖ that points to addr in the application pool. + +#### func (*F32ᵖ) Class + +```go +func (*F32ᵖ) Class() binary.Class +``` + +#### func (F32ᵖ) ElementSize + +```go +func (p F32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F32ᵖ points to. + +#### func (F32ᵖ) Read + +```go +func (p F32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) float32 +``` +Read reads and returns the float32 element at the pointer. + +#### func (F32ᵖ) Slice + +```go +func (p F32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) F32ˢ +``` +Slice returns a new F32ˢ from the pointer using start and end indices. + +#### func (F32ᵖ) String + +```go +func (p F32ᵖ) String() string ``` +String returns a string description of the F32ᵖ pointer. -#### type F32Array +#### func (F32ᵖ) Write ```go -type F32Array []float32 +func (p F32ᵖ) Write(value float32, ϟs *gfxapi.State) ``` +Write writes value to the float32 element at the pointer. +#### type F64ˢ -#### func (F32Array) Len +```go +type F64ˢ struct { + binary.Generate + SliceInfo +} +``` + +F64ˢ is a slice of float64. + +#### func AsF64ˢ + +```go +func AsF64ˢ(s Slice, ϟs *gfxapi.State) F64ˢ +``` +AsF64ˢ returns s cast to a F64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeF64ˢ + +```go +func MakeF64ˢ(count uint64, ϟs *gfxapi.State) F64ˢ +``` +MakeF64ˢ returns a F64ˢ backed by a new memory pool. + +#### func (*F64ˢ) Class + +```go +func (*F64ˢ) Class() binary.Class +``` + +#### func (F64ˢ) Clone + +```go +func (s F64ˢ) Clone(ϟs *gfxapi.State) F64ˢ +``` +Clone returns a copy of the F64ˢ in a new memory pool. + +#### func (F64ˢ) Copy + +```go +func (dst F64ˢ) Copy(src F64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s F64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (F64ˢ) Decoder + +```go +func (s F64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (F64ˢ) ElementSize + +```go +func (s F64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F64ˢ points to. + +#### func (F64ˢ) Encoder + +```go +func (s F64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (F64ˢ) Index + +```go +func (s F64ˢ) Index(i uint64, ϟs *gfxapi.State) F64ᵖ +``` +Index returns a F64ᵖ to the i'th element in this F64ˢ. + +#### func (F64ˢ) Range + +```go +func (s F64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (F64ˢ) Read + +```go +func (s F64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []float64 +``` +Read reads and returns all the float64 elements in this F64ˢ. + +#### func (F64ˢ) ResourceID + +```go +func (s F64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (F64ˢ) Slice + +```go +func (s F64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) F64ˢ +``` +Slice returns a sub-slice from the F64ˢ using start and end indices. + +#### func (F64ˢ) String + +```go +func (s F64ˢ) String() string +``` +String returns a string description of the F64ˢ slice. + +#### func (F64ˢ) Write + +```go +func (dst F64ˢ) Write(src []float64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type F64ᵖ + +```go +type F64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +F64ᵖ is a pointer to a float64 element. + +#### func NewF64ᵖ + +```go +func NewF64ᵖ(addr memory.Pointer) F64ᵖ +``` +NewF64ᵖ returns a F64ᵖ that points to addr in the application pool. + +#### func (*F64ᵖ) Class + +```go +func (*F64ᵖ) Class() binary.Class +``` + +#### func (F64ᵖ) ElementSize ```go -func (s F32Array) Len() int +func (p F64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that F64ᵖ points to. -#### func (F32Array) Range +#### func (F64ᵖ) Read ```go -func (s F32Array) Range() []float32 +func (p F64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) float64 ``` +Read reads and returns the float64 element at the pointer. + +#### func (F64ᵖ) Slice + +```go +func (p F64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) F64ˢ +``` +Slice returns a new F64ˢ from the pointer using start and end indices. + +#### func (F64ᵖ) String + +```go +func (p F64ᵖ) String() string +``` +String returns a string description of the F64ᵖ pointer. + +#### func (F64ᵖ) Write + +```go +func (p F64ᵖ) Write(value float64, ϟs *gfxapi.State) +``` +Write writes value to the float64 element at the pointer. #### type FaceMode @@ -3113,12 +6118,49 @@ type FaceMode uint32 enum FaceMode ////////////////////////////////////////////////////////////////////////////// +#### func (*FaceMode) Parse + +```go +func (v *FaceMode) Parse(s string) error +``` + #### func (FaceMode) String ```go func (v FaceMode) String() string ``` +#### type FaceModeːu32ᵐ + +```go +type FaceModeːu32ᵐ map[FaceMode]uint32 +``` + + +#### func (FaceModeːu32ᵐ) Contains + +```go +func (m FaceModeːu32ᵐ) Contains(key FaceMode) bool +``` + +#### func (FaceModeːu32ᵐ) Delete + +```go +func (m FaceModeːu32ᵐ) Delete(key FaceMode) +``` + +#### func (FaceModeːu32ᵐ) Get + +```go +func (m FaceModeːu32ᵐ) Get(key FaceMode) uint32 +``` + +#### func (FaceModeːu32ᵐ) Range + +```go +func (m FaceModeːu32ᵐ) Range() []uint32 +``` + #### type FaceOrientation ```go @@ -3129,6 +6171,12 @@ type FaceOrientation uint32 enum FaceOrientation ////////////////////////////////////////////////////////////////////////////// +#### func (*FaceOrientation) Parse + +```go +func (v *FaceOrientation) Parse(s string) error +``` + #### func (FaceOrientation) String ```go @@ -3159,6 +6207,22 @@ func NewFlushPostBuffer() *FlushPostBuffer func (c *FlushPostBuffer) API() gfxapi.API ``` +#### func (*FlushPostBuffer) AddRead + +```go +func (a *FlushPostBuffer) AddRead(rng memory.Range, id binary.ID) *FlushPostBuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The FlushPostBuffer pointer is returned so that calls can be chained. + +#### func (*FlushPostBuffer) AddWrite + +```go +func (a *FlushPostBuffer) AddWrite(rng memory.Range, id binary.ID) *FlushPostBuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The FlushPostBuffer pointer is returned so that calls can be chained. + #### func (*FlushPostBuffer) Class ```go @@ -3174,19 +6238,25 @@ func (c *FlushPostBuffer) Flags() atom.Flags #### func (*FlushPostBuffer) Mutate ```go -func (ϟa *FlushPostBuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *FlushPostBuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*FlushPostBuffer) Observations + +```go +func (a *FlushPostBuffer) Observations() *atom.Observations ``` #### func (*FlushPostBuffer) Replay ```go -func (ϟa *FlushPostBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *FlushPostBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*FlushPostBuffer) String ```go -func (c *FlushPostBuffer) String() string +func (a *FlushPostBuffer) String() string ``` #### func (*FlushPostBuffer) TypeID @@ -3201,7 +6271,7 @@ func (c *FlushPostBuffer) TypeID() atom.TypeID type Framebuffer struct { binary.Generate CreatedAt atom.ID - Attachments FramebufferAttachmentInfo_FramebufferAttachmentMap + Attachments FramebufferAttachmentːFramebufferAttachmentInfoᵐ } ``` @@ -3227,168 +6297,326 @@ func (c *Framebuffer) GetCreatedAt() atom.ID func (c *Framebuffer) Init() ``` -#### type FramebufferArray +#### type FramebufferAttachment ```go -type FramebufferArray []Framebuffer +type FramebufferAttachment uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum FramebufferAttachment +////////////////////////////////////////////////////////////////////////////// -#### func (FramebufferArray) Len +#### func (*FramebufferAttachment) Parse ```go -func (s FramebufferArray) Len() int +func (v *FramebufferAttachment) Parse(s string) error ``` -#### func (FramebufferArray) Range +#### func (FramebufferAttachment) String ```go -func (s FramebufferArray) Range() []Framebuffer +func (v FramebufferAttachment) String() string ``` -#### type FramebufferAttachable +#### type FramebufferAttachmentInfo ```go -type FramebufferAttachable interface { +type FramebufferAttachmentInfo struct { + binary.Generate + CreatedAt atom.ID + Object uint32 + Type FramebufferAttachmentType + TextureLevel int32 + CubeMapFace CubeMapImageTarget } ``` ////////////////////////////////////////////////////////////////////////////// -class FramebufferAttachable +class FramebufferAttachmentInfo ////////////////////////////////////////////////////////////////////////////// -#### type FramebufferAttachment +#### func (*FramebufferAttachmentInfo) Class ```go -type FramebufferAttachment uint32 +func (*FramebufferAttachmentInfo) Class() binary.Class +``` + +#### func (*FramebufferAttachmentInfo) GetCreatedAt + +```go +func (c *FramebufferAttachmentInfo) GetCreatedAt() atom.ID +``` + +#### func (*FramebufferAttachmentInfo) Init + +```go +func (c *FramebufferAttachmentInfo) Init() +``` + +#### type FramebufferAttachmentParameter + +```go +type FramebufferAttachmentParameter uint32 ``` ////////////////////////////////////////////////////////////////////////////// -enum FramebufferAttachment +enum FramebufferAttachmentParameter ////////////////////////////////////////////////////////////////////////////// -#### func (FramebufferAttachment) String +#### func (*FramebufferAttachmentParameter) Parse ```go -func (v FramebufferAttachment) String() string +func (v *FramebufferAttachmentParameter) Parse(s string) error ``` -#### type FramebufferAttachmentArray +#### func (FramebufferAttachmentParameter) String ```go -type FramebufferAttachmentArray []FramebufferAttachment +func (v FramebufferAttachmentParameter) String() string ``` +#### type FramebufferAttachmentType -#### func (FramebufferAttachmentArray) Len +```go +type FramebufferAttachmentType uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum FramebufferAttachmentType +////////////////////////////////////////////////////////////////////////////// + +#### func (*FramebufferAttachmentType) Parse ```go -func (s FramebufferAttachmentArray) Len() int +func (v *FramebufferAttachmentType) Parse(s string) error ``` -#### func (FramebufferAttachmentArray) Range +#### func (FramebufferAttachmentType) String ```go -func (s FramebufferAttachmentArray) Range() []FramebufferAttachment +func (v FramebufferAttachmentType) String() string ``` -#### type FramebufferAttachmentInfo +#### type FramebufferAttachmentːFramebufferAttachmentInfoᵐ ```go -type FramebufferAttachmentInfo struct { +type FramebufferAttachmentːFramebufferAttachmentInfoᵐ map[FramebufferAttachment]FramebufferAttachmentInfo +``` + + +#### func (FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Contains + +```go +func (m FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Contains(key FramebufferAttachment) bool +``` + +#### func (FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Delete + +```go +func (m FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Delete(key FramebufferAttachment) +``` + +#### func (FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Get + +```go +func (m FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Get(key FramebufferAttachment) FramebufferAttachmentInfo +``` + +#### func (FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Range + +```go +func (m FramebufferAttachmentːFramebufferAttachmentInfoᵐ) Range() []FramebufferAttachmentInfo +``` + +#### type FramebufferAttachmentˢ + +```go +type FramebufferAttachmentˢ struct { binary.Generate - CreatedAt atom.ID - Object uint32 - Type FramebufferAttachmentType - TextureLevel int32 - CubeMapFace CubeMapImageTarget + SliceInfo } ``` -////////////////////////////////////////////////////////////////////////////// -class FramebufferAttachmentInfo -////////////////////////////////////////////////////////////////////////////// +FramebufferAttachmentˢ is a slice of FramebufferAttachment. -#### func (*FramebufferAttachmentInfo) Class +#### func AsFramebufferAttachmentˢ ```go -func (*FramebufferAttachmentInfo) Class() binary.Class +func AsFramebufferAttachmentˢ(s Slice, ϟs *gfxapi.State) FramebufferAttachmentˢ ``` +AsFramebufferAttachmentˢ returns s cast to a FramebufferAttachmentˢ. The +returned slice length will be calculated so that the returned slice is no longer +(in bytes) than s. -#### func (*FramebufferAttachmentInfo) GetCreatedAt +#### func MakeFramebufferAttachmentˢ ```go -func (c *FramebufferAttachmentInfo) GetCreatedAt() atom.ID +func MakeFramebufferAttachmentˢ(count uint64, ϟs *gfxapi.State) FramebufferAttachmentˢ ``` +MakeFramebufferAttachmentˢ returns a FramebufferAttachmentˢ backed by a new +memory pool. -#### func (*FramebufferAttachmentInfo) Init +#### func (*FramebufferAttachmentˢ) Class ```go -func (c *FramebufferAttachmentInfo) Init() +func (*FramebufferAttachmentˢ) Class() binary.Class ``` -#### type FramebufferAttachmentInfo_FramebufferAttachmentMap +#### func (FramebufferAttachmentˢ) Clone ```go -type FramebufferAttachmentInfo_FramebufferAttachmentMap map[FramebufferAttachment]FramebufferAttachmentInfo +func (s FramebufferAttachmentˢ) Clone(ϟs *gfxapi.State) FramebufferAttachmentˢ ``` +Clone returns a copy of the FramebufferAttachmentˢ in a new memory pool. +#### func (FramebufferAttachmentˢ) Copy -#### func (FramebufferAttachmentInfo_FramebufferAttachmentMap) Contains +```go +func (dst FramebufferAttachmentˢ) Copy(src FramebufferAttachmentˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s FramebufferAttachmentˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (FramebufferAttachmentˢ) Decoder ```go -func (m FramebufferAttachmentInfo_FramebufferAttachmentMap) Contains(key FramebufferAttachment) bool +func (s FramebufferAttachmentˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (FramebufferAttachmentInfo_FramebufferAttachmentMap) Delete +#### func (FramebufferAttachmentˢ) ElementSize ```go -func (m FramebufferAttachmentInfo_FramebufferAttachmentMap) Delete(key FramebufferAttachment) +func (s FramebufferAttachmentˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that FramebufferAttachmentˢ +points to. -#### func (FramebufferAttachmentInfo_FramebufferAttachmentMap) Get +#### func (FramebufferAttachmentˢ) Encoder ```go -func (m FramebufferAttachmentInfo_FramebufferAttachmentMap) Get(key FramebufferAttachment) FramebufferAttachmentInfo +func (s FramebufferAttachmentˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (FramebufferAttachmentInfo_FramebufferAttachmentMap) Range +#### func (FramebufferAttachmentˢ) Index ```go -func (m FramebufferAttachmentInfo_FramebufferAttachmentMap) Range() []FramebufferAttachmentInfo +func (s FramebufferAttachmentˢ) Index(i uint64, ϟs *gfxapi.State) FramebufferAttachmentᵖ ``` +Index returns a FramebufferAttachmentᵖ to the i'th element in this +FramebufferAttachmentˢ. -#### type FramebufferAttachmentParameter +#### func (FramebufferAttachmentˢ) Range ```go -type FramebufferAttachmentParameter uint32 +func (s FramebufferAttachmentˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -////////////////////////////////////////////////////////////////////////////// -enum FramebufferAttachmentParameter -////////////////////////////////////////////////////////////////////////////// +#### func (FramebufferAttachmentˢ) Read -#### func (FramebufferAttachmentParameter) String +```go +func (s FramebufferAttachmentˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []FramebufferAttachment +``` +Read reads and returns all the FramebufferAttachment elements in this +FramebufferAttachmentˢ. + +#### func (FramebufferAttachmentˢ) ResourceID ```go -func (v FramebufferAttachmentParameter) String() string +func (s FramebufferAttachmentˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### type FramebufferAttachmentType +#### func (FramebufferAttachmentˢ) Slice ```go -type FramebufferAttachmentType uint32 +func (s FramebufferAttachmentˢ) Slice(start, end uint64, ϟs *gfxapi.State) FramebufferAttachmentˢ ``` +Slice returns a sub-slice from the FramebufferAttachmentˢ using start and end +indices. -////////////////////////////////////////////////////////////////////////////// -enum FramebufferAttachmentType -////////////////////////////////////////////////////////////////////////////// +#### func (FramebufferAttachmentˢ) String -#### func (FramebufferAttachmentType) String +```go +func (s FramebufferAttachmentˢ) String() string +``` +String returns a string description of the FramebufferAttachmentˢ slice. + +#### func (FramebufferAttachmentˢ) Write ```go -func (v FramebufferAttachmentType) String() string +func (dst FramebufferAttachmentˢ) Write(src []FramebufferAttachment, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type FramebufferAttachmentᵖ + +```go +type FramebufferAttachmentᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +FramebufferAttachmentᵖ is a pointer to a FramebufferAttachment element. + +#### func NewFramebufferAttachmentᵖ + +```go +func NewFramebufferAttachmentᵖ(addr memory.Pointer) FramebufferAttachmentᵖ +``` +NewFramebufferAttachmentᵖ returns a FramebufferAttachmentᵖ that points to addr +in the application pool. + +#### func (*FramebufferAttachmentᵖ) Class + +```go +func (*FramebufferAttachmentᵖ) Class() binary.Class +``` + +#### func (FramebufferAttachmentᵖ) ElementSize + +```go +func (p FramebufferAttachmentᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that FramebufferAttachmentᵖ +points to. + +#### func (FramebufferAttachmentᵖ) Read + +```go +func (p FramebufferAttachmentᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) FramebufferAttachment +``` +Read reads and returns the FramebufferAttachment element at the pointer. + +#### func (FramebufferAttachmentᵖ) Slice + +```go +func (p FramebufferAttachmentᵖ) Slice(start, end uint64, ϟs *gfxapi.State) FramebufferAttachmentˢ ``` +Slice returns a new FramebufferAttachmentˢ from the pointer using start and end +indices. + +#### func (FramebufferAttachmentᵖ) String + +```go +func (p FramebufferAttachmentᵖ) String() string +``` +String returns a string description of the FramebufferAttachmentᵖ pointer. + +#### func (FramebufferAttachmentᵖ) Write + +```go +func (p FramebufferAttachmentᵖ) Write(value FramebufferAttachment, ϟs *gfxapi.State) +``` +Write writes value to the FramebufferAttachment element at the pointer. #### type FramebufferId @@ -3397,98 +6625,219 @@ type FramebufferId uint32 ``` -#### func (*FramebufferId) Equal +#### type FramebufferIdːFramebufferʳᵐ ```go -func (c *FramebufferId) Equal(rhs FramebufferId) bool +type FramebufferIdːFramebufferʳᵐ map[FramebufferId](*Framebuffer) ``` -#### func (*FramebufferId) Less + +#### func (FramebufferIdːFramebufferʳᵐ) Contains ```go -func (c *FramebufferId) Less(rhs FramebufferId) bool +func (m FramebufferIdːFramebufferʳᵐ) Contains(key FramebufferId) bool ``` -#### type FramebufferIdArray +#### func (FramebufferIdːFramebufferʳᵐ) Delete ```go -type FramebufferIdArray []FramebufferId +func (m FramebufferIdːFramebufferʳᵐ) Delete(key FramebufferId) ``` +#### func (FramebufferIdːFramebufferʳᵐ) Get -#### func (FramebufferIdArray) Len +```go +func (m FramebufferIdːFramebufferʳᵐ) Get(key FramebufferId) *Framebuffer +``` + +#### func (FramebufferIdːFramebufferʳᵐ) Range ```go -func (s FramebufferIdArray) Len() int +func (m FramebufferIdːFramebufferʳᵐ) Range() [](*Framebuffer) ``` -#### func (FramebufferIdArray) Range +#### type FramebufferIdˢ ```go -func (s FramebufferIdArray) Range() []FramebufferId +type FramebufferIdˢ struct { + binary.Generate + SliceInfo +} ``` -#### type FramebufferId_FramebufferTargetMap +FramebufferIdˢ is a slice of FramebufferId. + +#### func AsFramebufferIdˢ ```go -type FramebufferId_FramebufferTargetMap map[FramebufferTarget]FramebufferId +func AsFramebufferIdˢ(s Slice, ϟs *gfxapi.State) FramebufferIdˢ ``` +AsFramebufferIdˢ returns s cast to a FramebufferIdˢ. The returned slice length +will be calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeFramebufferIdˢ +```go +func MakeFramebufferIdˢ(count uint64, ϟs *gfxapi.State) FramebufferIdˢ +``` +MakeFramebufferIdˢ returns a FramebufferIdˢ backed by a new memory pool. -#### func (FramebufferId_FramebufferTargetMap) Contains +#### func (*FramebufferIdˢ) Class ```go -func (m FramebufferId_FramebufferTargetMap) Contains(key FramebufferTarget) bool +func (*FramebufferIdˢ) Class() binary.Class ``` -#### func (FramebufferId_FramebufferTargetMap) Delete +#### func (FramebufferIdˢ) Clone ```go -func (m FramebufferId_FramebufferTargetMap) Delete(key FramebufferTarget) +func (s FramebufferIdˢ) Clone(ϟs *gfxapi.State) FramebufferIdˢ ``` +Clone returns a copy of the FramebufferIdˢ in a new memory pool. -#### func (FramebufferId_FramebufferTargetMap) Get +#### func (FramebufferIdˢ) Copy ```go -func (m FramebufferId_FramebufferTargetMap) Get(key FramebufferTarget) FramebufferId +func (dst FramebufferIdˢ) Copy(src FramebufferIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s FramebufferIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (FramebufferId_FramebufferTargetMap) Range +#### func (FramebufferIdˢ) Decoder ```go -func (m FramebufferId_FramebufferTargetMap) Range() []FramebufferId +func (s FramebufferIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### type FramebufferPtr_FramebufferIdMap +#### func (FramebufferIdˢ) ElementSize ```go -type FramebufferPtr_FramebufferIdMap map[FramebufferId]*Framebuffer +func (s FramebufferIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that FramebufferIdˢ points +to. +#### func (FramebufferIdˢ) Encoder -#### func (FramebufferPtr_FramebufferIdMap) Contains +```go +func (s FramebufferIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (FramebufferIdˢ) Index ```go -func (m FramebufferPtr_FramebufferIdMap) Contains(key FramebufferId) bool +func (s FramebufferIdˢ) Index(i uint64, ϟs *gfxapi.State) FramebufferIdᵖ ``` +Index returns a FramebufferIdᵖ to the i'th element in this FramebufferIdˢ. -#### func (FramebufferPtr_FramebufferIdMap) Delete +#### func (FramebufferIdˢ) Range ```go -func (m FramebufferPtr_FramebufferIdMap) Delete(key FramebufferId) +func (s FramebufferIdˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### func (FramebufferPtr_FramebufferIdMap) Get +#### func (FramebufferIdˢ) Read ```go -func (m FramebufferPtr_FramebufferIdMap) Get(key FramebufferId) *Framebuffer +func (s FramebufferIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []FramebufferId ``` +Read reads and returns all the FramebufferId elements in this FramebufferIdˢ. -#### func (FramebufferPtr_FramebufferIdMap) Range +#### func (FramebufferIdˢ) ResourceID ```go -func (m FramebufferPtr_FramebufferIdMap) Range() []*Framebuffer +func (s FramebufferIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (FramebufferIdˢ) Slice + +```go +func (s FramebufferIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) FramebufferIdˢ +``` +Slice returns a sub-slice from the FramebufferIdˢ using start and end indices. + +#### func (FramebufferIdˢ) String + +```go +func (s FramebufferIdˢ) String() string +``` +String returns a string description of the FramebufferIdˢ slice. + +#### func (FramebufferIdˢ) Write + +```go +func (dst FramebufferIdˢ) Write(src []FramebufferId, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type FramebufferIdᵖ + +```go +type FramebufferIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +FramebufferIdᵖ is a pointer to a FramebufferId element. + +#### func NewFramebufferIdᵖ + +```go +func NewFramebufferIdᵖ(addr memory.Pointer) FramebufferIdᵖ +``` +NewFramebufferIdᵖ returns a FramebufferIdᵖ that points to addr in the +application pool. + +#### func (*FramebufferIdᵖ) Class + +```go +func (*FramebufferIdᵖ) Class() binary.Class +``` + +#### func (FramebufferIdᵖ) ElementSize + +```go +func (p FramebufferIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that FramebufferIdᵖ points +to. + +#### func (FramebufferIdᵖ) Read + +```go +func (p FramebufferIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) FramebufferId +``` +Read reads and returns the FramebufferId element at the pointer. + +#### func (FramebufferIdᵖ) Slice + +```go +func (p FramebufferIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) FramebufferIdˢ +``` +Slice returns a new FramebufferIdˢ from the pointer using start and end indices. + +#### func (FramebufferIdᵖ) String + +```go +func (p FramebufferIdᵖ) String() string +``` +String returns a string description of the FramebufferIdᵖ pointer. + +#### func (FramebufferIdᵖ) Write + +```go +func (p FramebufferIdᵖ) Write(value FramebufferId, ϟs *gfxapi.State) +``` +Write writes value to the FramebufferId element at the pointer. #### type FramebufferStatus @@ -3500,6 +6849,12 @@ type FramebufferStatus uint32 enum FramebufferStatus ////////////////////////////////////////////////////////////////////////////// +#### func (*FramebufferStatus) Parse + +```go +func (v *FramebufferStatus) Parse(s string) error +``` + #### func (FramebufferStatus) String ```go @@ -3516,6 +6871,12 @@ type FramebufferTarget uint32 enum FramebufferTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*FramebufferTarget) Parse + +```go +func (v *FramebufferTarget) Parse(s string) error +``` + #### func (FramebufferTarget) String ```go @@ -3532,6 +6893,12 @@ type FramebufferTarget_GLES_2_0 uint32 enum FramebufferTarget_GLES_2_0 ////////////////////////////////////////////////////////////////////////////// +#### func (*FramebufferTarget_GLES_2_0) Parse + +```go +func (v *FramebufferTarget_GLES_2_0) Parse(s string) error +``` + #### func (FramebufferTarget_GLES_2_0) String ```go @@ -3548,55 +6915,179 @@ type FramebufferTarget_GLES_3_1 uint32 enum FramebufferTarget_GLES_3_1 ////////////////////////////////////////////////////////////////////////////// +#### func (*FramebufferTarget_GLES_3_1) Parse + +```go +func (v *FramebufferTarget_GLES_3_1) Parse(s string) error +``` + #### func (FramebufferTarget_GLES_3_1) String ```go func (v FramebufferTarget_GLES_3_1) String() string ``` +#### type FramebufferTargetːFramebufferIdᵐ + +```go +type FramebufferTargetːFramebufferIdᵐ map[FramebufferTarget]FramebufferId +``` + + +#### func (FramebufferTargetːFramebufferIdᵐ) Contains + +```go +func (m FramebufferTargetːFramebufferIdᵐ) Contains(key FramebufferTarget) bool +``` + +#### func (FramebufferTargetːFramebufferIdᵐ) Delete + +```go +func (m FramebufferTargetːFramebufferIdᵐ) Delete(key FramebufferTarget) +``` + +#### func (FramebufferTargetːFramebufferIdᵐ) Get + +```go +func (m FramebufferTargetːFramebufferIdᵐ) Get(key FramebufferTarget) FramebufferId +``` + +#### func (FramebufferTargetːFramebufferIdᵐ) Range + +```go +func (m FramebufferTargetːFramebufferIdᵐ) Range() []FramebufferId +``` + #### type GLXContext ```go -type GLXContext memory.Pointer +type GLXContext struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +GLXContext is a pointer to a void element. + +#### func NewGLXContext + +```go +func NewGLXContext(addr memory.Pointer) GLXContext +``` +NewGLXContext returns a GLXContext that points to addr in the application pool. + +#### func (*GLXContext) Class + +```go +func (*GLXContext) Class() binary.Class +``` + +#### func (GLXContext) ElementSize + +```go +func (p GLXContext) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that GLXContext points to. + +#### func (GLXContext) Slice + +```go +func (p GLXContext) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (GLXContext) String + +```go +func (p GLXContext) String() string +``` +String returns a string description of the GLXContext pointer. + +#### type GLXContextːContextʳᵐ + +```go +type GLXContextːContextʳᵐ map[GLXContext](*Context) +``` + + +#### func (GLXContextːContextʳᵐ) Contains + +```go +func (m GLXContextːContextʳᵐ) Contains(key GLXContext) bool ``` +#### func (GLXContextːContextʳᵐ) Delete -#### func (*GLXContext) Equal +```go +func (m GLXContextːContextʳᵐ) Delete(key GLXContext) +``` + +#### func (GLXContextːContextʳᵐ) Get ```go -func (c *GLXContext) Equal(rhs GLXContext) bool +func (m GLXContextːContextʳᵐ) Get(key GLXContext) *Context ``` -#### func (*GLXContext) Less +#### func (GLXContextːContextʳᵐ) Range ```go -func (c *GLXContext) Less(rhs GLXContext) bool +func (m GLXContextːContextʳᵐ) Range() [](*Context) ``` #### type GLXDrawable ```go -type GLXDrawable memory.Pointer +type GLXDrawable struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +GLXDrawable is a pointer to a void element. + +#### func NewGLXDrawable + +```go +func NewGLXDrawable(addr memory.Pointer) GLXDrawable ``` +NewGLXDrawable returns a GLXDrawable that points to addr in the application +pool. +#### func (*GLXDrawable) Class -#### func (*GLXDrawable) Equal +```go +func (*GLXDrawable) Class() binary.Class +``` + +#### func (GLXDrawable) ElementSize ```go -func (c *GLXDrawable) Equal(rhs GLXDrawable) bool +func (p GLXDrawable) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that GLXDrawable points to. -#### func (*GLXDrawable) Less +#### func (GLXDrawable) Slice ```go -func (c *GLXDrawable) Less(rhs GLXDrawable) bool +func (p GLXDrawable) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (GLXDrawable) String + +```go +func (p GLXDrawable) String() string +``` +String returns a string description of the GLXDrawable pointer. #### type GlActiveTexture ```go type GlActiveTexture struct { binary.Generate + Unit TextureUnit } ``` @@ -3608,9 +7099,7 @@ GlActiveTexture #### func NewGlActiveTexture ```go -func NewGlActiveTexture( - pUnit TextureUnit, -) *GlActiveTexture +func NewGlActiveTexture(Unit TextureUnit) *GlActiveTexture ``` #### func (*GlActiveTexture) API @@ -3619,6 +7108,22 @@ func NewGlActiveTexture( func (c *GlActiveTexture) API() gfxapi.API ``` +#### func (*GlActiveTexture) AddRead + +```go +func (a *GlActiveTexture) AddRead(rng memory.Range, id binary.ID) *GlActiveTexture +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlActiveTexture pointer is returned so that calls can be chained. + +#### func (*GlActiveTexture) AddWrite + +```go +func (a *GlActiveTexture) AddWrite(rng memory.Range, id binary.ID) *GlActiveTexture +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlActiveTexture pointer is returned so that calls can be chained. + #### func (*GlActiveTexture) Class ```go @@ -3634,19 +7139,25 @@ func (c *GlActiveTexture) Flags() atom.Flags #### func (*GlActiveTexture) Mutate ```go -func (ϟa *GlActiveTexture) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlActiveTexture) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlActiveTexture) Observations + +```go +func (a *GlActiveTexture) Observations() *atom.Observations ``` #### func (*GlActiveTexture) Replay ```go -func (ϟa *GlActiveTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlActiveTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlActiveTexture) String ```go -func (c *GlActiveTexture) String() string +func (a *GlActiveTexture) String() string ``` #### func (*GlActiveTexture) TypeID @@ -3660,6 +7171,7 @@ func (c *GlActiveTexture) TypeID() atom.TypeID ```go type GlAttachShader struct { binary.Generate + Program ProgramId Shader ShaderId } @@ -3672,10 +7184,7 @@ GlAttachShader #### func NewGlAttachShader ```go -func NewGlAttachShader( - pProgram ProgramId, - pShader ShaderId, -) *GlAttachShader +func NewGlAttachShader(Program ProgramId, Shader ShaderId) *GlAttachShader ``` #### func (*GlAttachShader) API @@ -3684,6 +7193,22 @@ func NewGlAttachShader( func (c *GlAttachShader) API() gfxapi.API ``` +#### func (*GlAttachShader) AddRead + +```go +func (a *GlAttachShader) AddRead(rng memory.Range, id binary.ID) *GlAttachShader +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlAttachShader pointer is returned so that calls can be chained. + +#### func (*GlAttachShader) AddWrite + +```go +func (a *GlAttachShader) AddWrite(rng memory.Range, id binary.ID) *GlAttachShader +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlAttachShader pointer is returned so that calls can be chained. + #### func (*GlAttachShader) Class ```go @@ -3699,19 +7224,25 @@ func (c *GlAttachShader) Flags() atom.Flags #### func (*GlAttachShader) Mutate ```go -func (ϟa *GlAttachShader) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlAttachShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlAttachShader) Observations + +```go +func (a *GlAttachShader) Observations() *atom.Observations ``` #### func (*GlAttachShader) Replay ```go -func (ϟa *GlAttachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlAttachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlAttachShader) String ```go -func (c *GlAttachShader) String() string +func (a *GlAttachShader) String() string ``` #### func (*GlAttachShader) TypeID @@ -3725,6 +7256,7 @@ func (c *GlAttachShader) TypeID() atom.TypeID ```go type GlBeginQuery struct { binary.Generate + Target QueryTarget Query QueryId } @@ -3737,10 +7269,7 @@ GlBeginQuery #### func NewGlBeginQuery ```go -func NewGlBeginQuery( - pTarget QueryTarget, - pQuery QueryId, -) *GlBeginQuery +func NewGlBeginQuery(Target QueryTarget, Query QueryId) *GlBeginQuery ``` #### func (*GlBeginQuery) API @@ -3749,6 +7278,22 @@ func NewGlBeginQuery( func (c *GlBeginQuery) API() gfxapi.API ``` +#### func (*GlBeginQuery) AddRead + +```go +func (a *GlBeginQuery) AddRead(rng memory.Range, id binary.ID) *GlBeginQuery +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBeginQuery pointer is returned so that calls can be chained. + +#### func (*GlBeginQuery) AddWrite + +```go +func (a *GlBeginQuery) AddWrite(rng memory.Range, id binary.ID) *GlBeginQuery +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBeginQuery pointer is returned so that calls can be chained. + #### func (*GlBeginQuery) Class ```go @@ -3764,19 +7309,25 @@ func (c *GlBeginQuery) Flags() atom.Flags #### func (*GlBeginQuery) Mutate ```go -func (ϟa *GlBeginQuery) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBeginQuery) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBeginQuery) Observations + +```go +func (a *GlBeginQuery) Observations() *atom.Observations ``` #### func (*GlBeginQuery) Replay ```go -func (ϟa *GlBeginQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBeginQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBeginQuery) String ```go -func (c *GlBeginQuery) String() string +func (a *GlBeginQuery) String() string ``` #### func (*GlBeginQuery) TypeID @@ -3790,6 +7341,7 @@ func (c *GlBeginQuery) TypeID() atom.TypeID ```go type GlBeginQueryEXT struct { binary.Generate + Target QueryTarget Query QueryId } @@ -3802,10 +7354,7 @@ GlBeginQueryEXT #### func NewGlBeginQueryEXT ```go -func NewGlBeginQueryEXT( - pTarget QueryTarget, - pQuery QueryId, -) *GlBeginQueryEXT +func NewGlBeginQueryEXT(Target QueryTarget, Query QueryId) *GlBeginQueryEXT ``` #### func (*GlBeginQueryEXT) API @@ -3814,6 +7363,22 @@ func NewGlBeginQueryEXT( func (c *GlBeginQueryEXT) API() gfxapi.API ``` +#### func (*GlBeginQueryEXT) AddRead + +```go +func (a *GlBeginQueryEXT) AddRead(rng memory.Range, id binary.ID) *GlBeginQueryEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBeginQueryEXT pointer is returned so that calls can be chained. + +#### func (*GlBeginQueryEXT) AddWrite + +```go +func (a *GlBeginQueryEXT) AddWrite(rng memory.Range, id binary.ID) *GlBeginQueryEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBeginQueryEXT pointer is returned so that calls can be chained. + #### func (*GlBeginQueryEXT) Class ```go @@ -3829,19 +7394,25 @@ func (c *GlBeginQueryEXT) Flags() atom.Flags #### func (*GlBeginQueryEXT) Mutate ```go -func (ϟa *GlBeginQueryEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBeginQueryEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBeginQueryEXT) Observations + +```go +func (a *GlBeginQueryEXT) Observations() *atom.Observations ``` #### func (*GlBeginQueryEXT) Replay ```go -func (ϟa *GlBeginQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBeginQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBeginQueryEXT) String ```go -func (c *GlBeginQueryEXT) String() string +func (a *GlBeginQueryEXT) String() string ``` #### func (*GlBeginQueryEXT) TypeID @@ -3855,6 +7426,7 @@ func (c *GlBeginQueryEXT) TypeID() atom.TypeID ```go type GlBindAttribLocation struct { binary.Generate + Program ProgramId Location AttributeLocation Name string @@ -3868,11 +7440,7 @@ GlBindAttribLocation #### func NewGlBindAttribLocation ```go -func NewGlBindAttribLocation( - pProgram ProgramId, - pLocation AttributeLocation, - pName string, -) *GlBindAttribLocation +func NewGlBindAttribLocation(Program ProgramId, Location AttributeLocation, Name string) *GlBindAttribLocation ``` #### func (*GlBindAttribLocation) API @@ -3881,6 +7449,24 @@ func NewGlBindAttribLocation( func (c *GlBindAttribLocation) API() gfxapi.API ``` +#### func (*GlBindAttribLocation) AddRead + +```go +func (a *GlBindAttribLocation) AddRead(rng memory.Range, id binary.ID) *GlBindAttribLocation +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindAttribLocation pointer is returned so that calls can be +chained. + +#### func (*GlBindAttribLocation) AddWrite + +```go +func (a *GlBindAttribLocation) AddWrite(rng memory.Range, id binary.ID) *GlBindAttribLocation +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindAttribLocation pointer is returned so that calls can be +chained. + #### func (*GlBindAttribLocation) Class ```go @@ -3896,19 +7482,25 @@ func (c *GlBindAttribLocation) Flags() atom.Flags #### func (*GlBindAttribLocation) Mutate ```go -func (ϟa *GlBindAttribLocation) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindAttribLocation) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindAttribLocation) Observations + +```go +func (a *GlBindAttribLocation) Observations() *atom.Observations ``` #### func (*GlBindAttribLocation) Replay ```go -func (ϟa *GlBindAttribLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindAttribLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindAttribLocation) String ```go -func (c *GlBindAttribLocation) String() string +func (a *GlBindAttribLocation) String() string ``` #### func (*GlBindAttribLocation) TypeID @@ -3922,6 +7514,7 @@ func (c *GlBindAttribLocation) TypeID() atom.TypeID ```go type GlBindBuffer struct { binary.Generate + Target BufferTarget Buffer BufferId } @@ -3934,10 +7527,7 @@ GlBindBuffer #### func NewGlBindBuffer ```go -func NewGlBindBuffer( - pTarget BufferTarget, - pBuffer BufferId, -) *GlBindBuffer +func NewGlBindBuffer(Target BufferTarget, Buffer BufferId) *GlBindBuffer ``` #### func (*GlBindBuffer) API @@ -3946,6 +7536,22 @@ func NewGlBindBuffer( func (c *GlBindBuffer) API() gfxapi.API ``` +#### func (*GlBindBuffer) AddRead + +```go +func (a *GlBindBuffer) AddRead(rng memory.Range, id binary.ID) *GlBindBuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindBuffer pointer is returned so that calls can be chained. + +#### func (*GlBindBuffer) AddWrite + +```go +func (a *GlBindBuffer) AddWrite(rng memory.Range, id binary.ID) *GlBindBuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindBuffer pointer is returned so that calls can be chained. + #### func (*GlBindBuffer) Class ```go @@ -3961,19 +7567,25 @@ func (c *GlBindBuffer) Flags() atom.Flags #### func (*GlBindBuffer) Mutate ```go -func (ϟa *GlBindBuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindBuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindBuffer) Observations + +```go +func (a *GlBindBuffer) Observations() *atom.Observations ``` #### func (*GlBindBuffer) Replay ```go -func (ϟa *GlBindBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindBuffer) String ```go -func (c *GlBindBuffer) String() string +func (a *GlBindBuffer) String() string ``` #### func (*GlBindBuffer) TypeID @@ -3982,11 +7594,98 @@ func (c *GlBindBuffer) String() string func (c *GlBindBuffer) TypeID() atom.TypeID ``` +#### type GlBindBufferBase + +```go +type GlBindBufferBase struct { + binary.Generate + + Target IndexedBufferTarget + Index uint32 + Buffer BufferId +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlBindBufferBase +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlBindBufferBase + +```go +func NewGlBindBufferBase(Target IndexedBufferTarget, Index uint32, Buffer BufferId) *GlBindBufferBase +``` + +#### func (*GlBindBufferBase) API + +```go +func (c *GlBindBufferBase) API() gfxapi.API +``` + +#### func (*GlBindBufferBase) AddRead + +```go +func (a *GlBindBufferBase) AddRead(rng memory.Range, id binary.ID) *GlBindBufferBase +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindBufferBase pointer is returned so that calls can be chained. + +#### func (*GlBindBufferBase) AddWrite + +```go +func (a *GlBindBufferBase) AddWrite(rng memory.Range, id binary.ID) *GlBindBufferBase +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindBufferBase pointer is returned so that calls can be chained. + +#### func (*GlBindBufferBase) Class + +```go +func (*GlBindBufferBase) Class() binary.Class +``` + +#### func (*GlBindBufferBase) Flags + +```go +func (c *GlBindBufferBase) Flags() atom.Flags +``` + +#### func (*GlBindBufferBase) Mutate + +```go +func (ϟa *GlBindBufferBase) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindBufferBase) Observations + +```go +func (a *GlBindBufferBase) Observations() *atom.Observations +``` + +#### func (*GlBindBufferBase) Replay + +```go +func (ϟa *GlBindBufferBase) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlBindBufferBase) String + +```go +func (a *GlBindBufferBase) String() string +``` + +#### func (*GlBindBufferBase) TypeID + +```go +func (c *GlBindBufferBase) TypeID() atom.TypeID +``` + #### type GlBindFramebuffer ```go type GlBindFramebuffer struct { binary.Generate + Target FramebufferTarget Framebuffer FramebufferId } @@ -3999,10 +7698,7 @@ GlBindFramebuffer #### func NewGlBindFramebuffer ```go -func NewGlBindFramebuffer( - pTarget FramebufferTarget, - pFramebuffer FramebufferId, -) *GlBindFramebuffer +func NewGlBindFramebuffer(Target FramebufferTarget, Framebuffer FramebufferId) *GlBindFramebuffer ``` #### func (*GlBindFramebuffer) API @@ -4011,6 +7707,22 @@ func NewGlBindFramebuffer( func (c *GlBindFramebuffer) API() gfxapi.API ``` +#### func (*GlBindFramebuffer) AddRead + +```go +func (a *GlBindFramebuffer) AddRead(rng memory.Range, id binary.ID) *GlBindFramebuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindFramebuffer pointer is returned so that calls can be chained. + +#### func (*GlBindFramebuffer) AddWrite + +```go +func (a *GlBindFramebuffer) AddWrite(rng memory.Range, id binary.ID) *GlBindFramebuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindFramebuffer pointer is returned so that calls can be chained. + #### func (*GlBindFramebuffer) Class ```go @@ -4026,19 +7738,25 @@ func (c *GlBindFramebuffer) Flags() atom.Flags #### func (*GlBindFramebuffer) Mutate ```go -func (ϟa *GlBindFramebuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindFramebuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindFramebuffer) Observations + +```go +func (a *GlBindFramebuffer) Observations() *atom.Observations ``` #### func (*GlBindFramebuffer) Replay ```go -func (ϟa *GlBindFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindFramebuffer) String ```go -func (c *GlBindFramebuffer) String() string +func (a *GlBindFramebuffer) String() string ``` #### func (*GlBindFramebuffer) TypeID @@ -4052,6 +7770,7 @@ func (c *GlBindFramebuffer) TypeID() atom.TypeID ```go type GlBindRenderbuffer struct { binary.Generate + Target RenderbufferTarget Renderbuffer RenderbufferId } @@ -4064,10 +7783,7 @@ GlBindRenderbuffer #### func NewGlBindRenderbuffer ```go -func NewGlBindRenderbuffer( - pTarget RenderbufferTarget, - pRenderbuffer RenderbufferId, -) *GlBindRenderbuffer +func NewGlBindRenderbuffer(Target RenderbufferTarget, Renderbuffer RenderbufferId) *GlBindRenderbuffer ``` #### func (*GlBindRenderbuffer) API @@ -4076,6 +7792,24 @@ func NewGlBindRenderbuffer( func (c *GlBindRenderbuffer) API() gfxapi.API ``` +#### func (*GlBindRenderbuffer) AddRead + +```go +func (a *GlBindRenderbuffer) AddRead(rng memory.Range, id binary.ID) *GlBindRenderbuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindRenderbuffer pointer is returned so that calls can be +chained. + +#### func (*GlBindRenderbuffer) AddWrite + +```go +func (a *GlBindRenderbuffer) AddWrite(rng memory.Range, id binary.ID) *GlBindRenderbuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindRenderbuffer pointer is returned so that calls can be +chained. + #### func (*GlBindRenderbuffer) Class ```go @@ -4091,19 +7825,25 @@ func (c *GlBindRenderbuffer) Flags() atom.Flags #### func (*GlBindRenderbuffer) Mutate ```go -func (ϟa *GlBindRenderbuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindRenderbuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindRenderbuffer) Observations + +```go +func (a *GlBindRenderbuffer) Observations() *atom.Observations ``` #### func (*GlBindRenderbuffer) Replay ```go -func (ϟa *GlBindRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindRenderbuffer) String ```go -func (c *GlBindRenderbuffer) String() string +func (a *GlBindRenderbuffer) String() string ``` #### func (*GlBindRenderbuffer) TypeID @@ -4117,6 +7857,7 @@ func (c *GlBindRenderbuffer) TypeID() atom.TypeID ```go type GlBindTexture struct { binary.Generate + Target TextureTarget Texture TextureId } @@ -4129,10 +7870,7 @@ GlBindTexture #### func NewGlBindTexture ```go -func NewGlBindTexture( - pTarget TextureTarget, - pTexture TextureId, -) *GlBindTexture +func NewGlBindTexture(Target TextureTarget, Texture TextureId) *GlBindTexture ``` #### func (*GlBindTexture) API @@ -4141,6 +7879,22 @@ func NewGlBindTexture( func (c *GlBindTexture) API() gfxapi.API ``` +#### func (*GlBindTexture) AddRead + +```go +func (a *GlBindTexture) AddRead(rng memory.Range, id binary.ID) *GlBindTexture +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindTexture pointer is returned so that calls can be chained. + +#### func (*GlBindTexture) AddWrite + +```go +func (a *GlBindTexture) AddWrite(rng memory.Range, id binary.ID) *GlBindTexture +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindTexture pointer is returned so that calls can be chained. + #### func (*GlBindTexture) Class ```go @@ -4156,19 +7910,25 @@ func (c *GlBindTexture) Flags() atom.Flags #### func (*GlBindTexture) Mutate ```go -func (ϟa *GlBindTexture) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindTexture) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindTexture) Observations + +```go +func (a *GlBindTexture) Observations() *atom.Observations ``` #### func (*GlBindTexture) Replay ```go -func (ϟa *GlBindTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindTexture) String ```go -func (c *GlBindTexture) String() string +func (a *GlBindTexture) String() string ``` #### func (*GlBindTexture) TypeID @@ -4177,11 +7937,96 @@ func (c *GlBindTexture) String() string func (c *GlBindTexture) TypeID() atom.TypeID ``` +#### type GlBindVertexArray + +```go +type GlBindVertexArray struct { + binary.Generate + + Array VertexArrayId +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlBindVertexArray +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlBindVertexArray + +```go +func NewGlBindVertexArray(Array VertexArrayId) *GlBindVertexArray +``` + +#### func (*GlBindVertexArray) API + +```go +func (c *GlBindVertexArray) API() gfxapi.API +``` + +#### func (*GlBindVertexArray) AddRead + +```go +func (a *GlBindVertexArray) AddRead(rng memory.Range, id binary.ID) *GlBindVertexArray +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindVertexArray pointer is returned so that calls can be chained. + +#### func (*GlBindVertexArray) AddWrite + +```go +func (a *GlBindVertexArray) AddWrite(rng memory.Range, id binary.ID) *GlBindVertexArray +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindVertexArray pointer is returned so that calls can be chained. + +#### func (*GlBindVertexArray) Class + +```go +func (*GlBindVertexArray) Class() binary.Class +``` + +#### func (*GlBindVertexArray) Flags + +```go +func (c *GlBindVertexArray) Flags() atom.Flags +``` + +#### func (*GlBindVertexArray) Mutate + +```go +func (ϟa *GlBindVertexArray) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindVertexArray) Observations + +```go +func (a *GlBindVertexArray) Observations() *atom.Observations +``` + +#### func (*GlBindVertexArray) Replay + +```go +func (ϟa *GlBindVertexArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlBindVertexArray) String + +```go +func (a *GlBindVertexArray) String() string +``` + +#### func (*GlBindVertexArray) TypeID + +```go +func (c *GlBindVertexArray) TypeID() atom.TypeID +``` + #### type GlBindVertexArrayOES ```go type GlBindVertexArrayOES struct { binary.Generate + Array VertexArrayId } ``` @@ -4193,9 +8038,7 @@ GlBindVertexArrayOES #### func NewGlBindVertexArrayOES ```go -func NewGlBindVertexArrayOES( - pArray VertexArrayId, -) *GlBindVertexArrayOES +func NewGlBindVertexArrayOES(Array VertexArrayId) *GlBindVertexArrayOES ``` #### func (*GlBindVertexArrayOES) API @@ -4204,6 +8047,24 @@ func NewGlBindVertexArrayOES( func (c *GlBindVertexArrayOES) API() gfxapi.API ``` +#### func (*GlBindVertexArrayOES) AddRead + +```go +func (a *GlBindVertexArrayOES) AddRead(rng memory.Range, id binary.ID) *GlBindVertexArrayOES +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBindVertexArrayOES pointer is returned so that calls can be +chained. + +#### func (*GlBindVertexArrayOES) AddWrite + +```go +func (a *GlBindVertexArrayOES) AddWrite(rng memory.Range, id binary.ID) *GlBindVertexArrayOES +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBindVertexArrayOES pointer is returned so that calls can be +chained. + #### func (*GlBindVertexArrayOES) Class ```go @@ -4219,19 +8080,25 @@ func (c *GlBindVertexArrayOES) Flags() atom.Flags #### func (*GlBindVertexArrayOES) Mutate ```go -func (ϟa *GlBindVertexArrayOES) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBindVertexArrayOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBindVertexArrayOES) Observations + +```go +func (a *GlBindVertexArrayOES) Observations() *atom.Observations ``` #### func (*GlBindVertexArrayOES) Replay ```go -func (ϟa *GlBindVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBindVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBindVertexArrayOES) String ```go -func (c *GlBindVertexArrayOES) String() string +func (a *GlBindVertexArrayOES) String() string ``` #### func (*GlBindVertexArrayOES) TypeID @@ -4245,6 +8112,7 @@ func (c *GlBindVertexArrayOES) TypeID() atom.TypeID ```go type GlBlendColor struct { binary.Generate + Red float32 Green float32 Blue float32 @@ -4259,12 +8127,7 @@ GlBlendColor #### func NewGlBlendColor ```go -func NewGlBlendColor( - pRed float32, - pGreen float32, - pBlue float32, - pAlpha float32, -) *GlBlendColor +func NewGlBlendColor(Red float32, Green float32, Blue float32, Alpha float32) *GlBlendColor ``` #### func (*GlBlendColor) API @@ -4273,6 +8136,22 @@ func NewGlBlendColor( func (c *GlBlendColor) API() gfxapi.API ``` +#### func (*GlBlendColor) AddRead + +```go +func (a *GlBlendColor) AddRead(rng memory.Range, id binary.ID) *GlBlendColor +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlendColor pointer is returned so that calls can be chained. + +#### func (*GlBlendColor) AddWrite + +```go +func (a *GlBlendColor) AddWrite(rng memory.Range, id binary.ID) *GlBlendColor +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlendColor pointer is returned so that calls can be chained. + #### func (*GlBlendColor) Class ```go @@ -4288,19 +8167,25 @@ func (c *GlBlendColor) Flags() atom.Flags #### func (*GlBlendColor) Mutate ```go -func (ϟa *GlBlendColor) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlendColor) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlendColor) Observations + +```go +func (a *GlBlendColor) Observations() *atom.Observations ``` #### func (*GlBlendColor) Replay ```go -func (ϟa *GlBlendColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlendColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlendColor) String ```go -func (c *GlBlendColor) String() string +func (a *GlBlendColor) String() string ``` #### func (*GlBlendColor) TypeID @@ -4314,6 +8199,7 @@ func (c *GlBlendColor) TypeID() atom.TypeID ```go type GlBlendEquation struct { binary.Generate + Equation BlendEquation } ``` @@ -4325,9 +8211,7 @@ GlBlendEquation #### func NewGlBlendEquation ```go -func NewGlBlendEquation( - pEquation BlendEquation, -) *GlBlendEquation +func NewGlBlendEquation(Equation BlendEquation) *GlBlendEquation ``` #### func (*GlBlendEquation) API @@ -4336,6 +8220,22 @@ func NewGlBlendEquation( func (c *GlBlendEquation) API() gfxapi.API ``` +#### func (*GlBlendEquation) AddRead + +```go +func (a *GlBlendEquation) AddRead(rng memory.Range, id binary.ID) *GlBlendEquation +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlendEquation pointer is returned so that calls can be chained. + +#### func (*GlBlendEquation) AddWrite + +```go +func (a *GlBlendEquation) AddWrite(rng memory.Range, id binary.ID) *GlBlendEquation +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlendEquation pointer is returned so that calls can be chained. + #### func (*GlBlendEquation) Class ```go @@ -4351,19 +8251,25 @@ func (c *GlBlendEquation) Flags() atom.Flags #### func (*GlBlendEquation) Mutate ```go -func (ϟa *GlBlendEquation) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlendEquation) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlendEquation) Observations + +```go +func (a *GlBlendEquation) Observations() *atom.Observations ``` #### func (*GlBlendEquation) Replay ```go -func (ϟa *GlBlendEquation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlendEquation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlendEquation) String ```go -func (c *GlBlendEquation) String() string +func (a *GlBlendEquation) String() string ``` #### func (*GlBlendEquation) TypeID @@ -4377,6 +8283,7 @@ func (c *GlBlendEquation) TypeID() atom.TypeID ```go type GlBlendEquationSeparate struct { binary.Generate + Rgb BlendEquation Alpha BlendEquation } @@ -4389,10 +8296,7 @@ GlBlendEquationSeparate #### func NewGlBlendEquationSeparate ```go -func NewGlBlendEquationSeparate( - pRgb BlendEquation, - pAlpha BlendEquation, -) *GlBlendEquationSeparate +func NewGlBlendEquationSeparate(Rgb BlendEquation, Alpha BlendEquation) *GlBlendEquationSeparate ``` #### func (*GlBlendEquationSeparate) API @@ -4401,6 +8305,24 @@ func NewGlBlendEquationSeparate( func (c *GlBlendEquationSeparate) API() gfxapi.API ``` +#### func (*GlBlendEquationSeparate) AddRead + +```go +func (a *GlBlendEquationSeparate) AddRead(rng memory.Range, id binary.ID) *GlBlendEquationSeparate +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlendEquationSeparate pointer is returned so that calls can be +chained. + +#### func (*GlBlendEquationSeparate) AddWrite + +```go +func (a *GlBlendEquationSeparate) AddWrite(rng memory.Range, id binary.ID) *GlBlendEquationSeparate +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlendEquationSeparate pointer is returned so that calls can be +chained. + #### func (*GlBlendEquationSeparate) Class ```go @@ -4416,19 +8338,25 @@ func (c *GlBlendEquationSeparate) Flags() atom.Flags #### func (*GlBlendEquationSeparate) Mutate ```go -func (ϟa *GlBlendEquationSeparate) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlendEquationSeparate) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlendEquationSeparate) Observations + +```go +func (a *GlBlendEquationSeparate) Observations() *atom.Observations ``` #### func (*GlBlendEquationSeparate) Replay ```go -func (ϟa *GlBlendEquationSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlendEquationSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlendEquationSeparate) String ```go -func (c *GlBlendEquationSeparate) String() string +func (a *GlBlendEquationSeparate) String() string ``` #### func (*GlBlendEquationSeparate) TypeID @@ -4442,6 +8370,7 @@ func (c *GlBlendEquationSeparate) TypeID() atom.TypeID ```go type GlBlendFunc struct { binary.Generate + SrcFactor BlendFactor DstFactor BlendFactor } @@ -4454,10 +8383,7 @@ GlBlendFunc #### func NewGlBlendFunc ```go -func NewGlBlendFunc( - pSrcFactor BlendFactor, - pDstFactor BlendFactor, -) *GlBlendFunc +func NewGlBlendFunc(Src_factor BlendFactor, Dst_factor BlendFactor) *GlBlendFunc ``` #### func (*GlBlendFunc) API @@ -4466,6 +8392,22 @@ func NewGlBlendFunc( func (c *GlBlendFunc) API() gfxapi.API ``` +#### func (*GlBlendFunc) AddRead + +```go +func (a *GlBlendFunc) AddRead(rng memory.Range, id binary.ID) *GlBlendFunc +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlendFunc pointer is returned so that calls can be chained. + +#### func (*GlBlendFunc) AddWrite + +```go +func (a *GlBlendFunc) AddWrite(rng memory.Range, id binary.ID) *GlBlendFunc +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlendFunc pointer is returned so that calls can be chained. + #### func (*GlBlendFunc) Class ```go @@ -4481,19 +8423,25 @@ func (c *GlBlendFunc) Flags() atom.Flags #### func (*GlBlendFunc) Mutate ```go -func (ϟa *GlBlendFunc) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlendFunc) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlendFunc) Observations + +```go +func (a *GlBlendFunc) Observations() *atom.Observations ``` #### func (*GlBlendFunc) Replay ```go -func (ϟa *GlBlendFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlendFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlendFunc) String ```go -func (c *GlBlendFunc) String() string +func (a *GlBlendFunc) String() string ``` #### func (*GlBlendFunc) TypeID @@ -4507,6 +8455,7 @@ func (c *GlBlendFunc) TypeID() atom.TypeID ```go type GlBlendFuncSeparate struct { binary.Generate + SrcFactorRgb BlendFactor DstFactorRgb BlendFactor SrcFactorAlpha BlendFactor @@ -4521,12 +8470,7 @@ GlBlendFuncSeparate #### func NewGlBlendFuncSeparate ```go -func NewGlBlendFuncSeparate( - pSrcFactorRgb BlendFactor, - pDstFactorRgb BlendFactor, - pSrcFactorAlpha BlendFactor, - pDstFactorAlpha BlendFactor, -) *GlBlendFuncSeparate +func NewGlBlendFuncSeparate(Src_factor_rgb BlendFactor, Dst_factor_rgb BlendFactor, Src_factor_alpha BlendFactor, Dst_factor_alpha BlendFactor) *GlBlendFuncSeparate ``` #### func (*GlBlendFuncSeparate) API @@ -4535,6 +8479,24 @@ func NewGlBlendFuncSeparate( func (c *GlBlendFuncSeparate) API() gfxapi.API ``` +#### func (*GlBlendFuncSeparate) AddRead + +```go +func (a *GlBlendFuncSeparate) AddRead(rng memory.Range, id binary.ID) *GlBlendFuncSeparate +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlendFuncSeparate pointer is returned so that calls can be +chained. + +#### func (*GlBlendFuncSeparate) AddWrite + +```go +func (a *GlBlendFuncSeparate) AddWrite(rng memory.Range, id binary.ID) *GlBlendFuncSeparate +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlendFuncSeparate pointer is returned so that calls can be +chained. + #### func (*GlBlendFuncSeparate) Class ```go @@ -4550,19 +8512,25 @@ func (c *GlBlendFuncSeparate) Flags() atom.Flags #### func (*GlBlendFuncSeparate) Mutate ```go -func (ϟa *GlBlendFuncSeparate) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlendFuncSeparate) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlendFuncSeparate) Observations + +```go +func (a *GlBlendFuncSeparate) Observations() *atom.Observations ``` #### func (*GlBlendFuncSeparate) Replay ```go -func (ϟa *GlBlendFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlendFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlendFuncSeparate) String ```go -func (c *GlBlendFuncSeparate) String() string +func (a *GlBlendFuncSeparate) String() string ``` #### func (*GlBlendFuncSeparate) TypeID @@ -4576,6 +8544,7 @@ func (c *GlBlendFuncSeparate) TypeID() atom.TypeID ```go type GlBlitFramebuffer struct { binary.Generate + SrcX0 int32 SrcY0 int32 SrcX1 int32 @@ -4596,18 +8565,7 @@ GlBlitFramebuffer #### func NewGlBlitFramebuffer ```go -func NewGlBlitFramebuffer( - pSrcX0 int32, - pSrcY0 int32, - pSrcX1 int32, - pSrcY1 int32, - pDstX0 int32, - pDstY0 int32, - pDstX1 int32, - pDstY1 int32, - pMask ClearMask, - pFilter TextureFilterMode, -) *GlBlitFramebuffer +func NewGlBlitFramebuffer(SrcX0 int32, SrcY0 int32, SrcX1 int32, SrcY1 int32, DstX0 int32, DstY0 int32, DstX1 int32, DstY1 int32, Mask ClearMask, Filter TextureFilterMode) *GlBlitFramebuffer ``` #### func (*GlBlitFramebuffer) API @@ -4616,6 +8574,22 @@ func NewGlBlitFramebuffer( func (c *GlBlitFramebuffer) API() gfxapi.API ``` +#### func (*GlBlitFramebuffer) AddRead + +```go +func (a *GlBlitFramebuffer) AddRead(rng memory.Range, id binary.ID) *GlBlitFramebuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBlitFramebuffer pointer is returned so that calls can be chained. + +#### func (*GlBlitFramebuffer) AddWrite + +```go +func (a *GlBlitFramebuffer) AddWrite(rng memory.Range, id binary.ID) *GlBlitFramebuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBlitFramebuffer pointer is returned so that calls can be chained. + #### func (*GlBlitFramebuffer) Class ```go @@ -4631,19 +8605,25 @@ func (c *GlBlitFramebuffer) Flags() atom.Flags #### func (*GlBlitFramebuffer) Mutate ```go -func (ϟa *GlBlitFramebuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBlitFramebuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBlitFramebuffer) Observations + +```go +func (a *GlBlitFramebuffer) Observations() *atom.Observations ``` #### func (*GlBlitFramebuffer) Replay ```go -func (ϟa *GlBlitFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBlitFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBlitFramebuffer) String ```go -func (c *GlBlitFramebuffer) String() string +func (a *GlBlitFramebuffer) String() string ``` #### func (*GlBlitFramebuffer) TypeID @@ -4657,6 +8637,7 @@ func (c *GlBlitFramebuffer) TypeID() atom.TypeID ```go type GlBufferData struct { binary.Generate + Target BufferTarget Size int32 Data BufferDataPointer @@ -4671,12 +8652,7 @@ GlBufferData #### func NewGlBufferData ```go -func NewGlBufferData( - pTarget BufferTarget, - pSize int32, - pData BufferDataPointer, - pUsage BufferUsage, -) *GlBufferData +func NewGlBufferData(Target BufferTarget, Size int32, Data memory.Pointer, Usage BufferUsage) *GlBufferData ``` #### func (*GlBufferData) API @@ -4685,6 +8661,22 @@ func NewGlBufferData( func (c *GlBufferData) API() gfxapi.API ``` +#### func (*GlBufferData) AddRead + +```go +func (a *GlBufferData) AddRead(rng memory.Range, id binary.ID) *GlBufferData +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBufferData pointer is returned so that calls can be chained. + +#### func (*GlBufferData) AddWrite + +```go +func (a *GlBufferData) AddWrite(rng memory.Range, id binary.ID) *GlBufferData +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBufferData pointer is returned so that calls can be chained. + #### func (*GlBufferData) Class ```go @@ -4700,19 +8692,25 @@ func (c *GlBufferData) Flags() atom.Flags #### func (*GlBufferData) Mutate ```go -func (ϟa *GlBufferData) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBufferData) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBufferData) Observations + +```go +func (a *GlBufferData) Observations() *atom.Observations ``` #### func (*GlBufferData) Replay ```go -func (ϟa *GlBufferData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBufferData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBufferData) String ```go -func (c *GlBufferData) String() string +func (a *GlBufferData) String() string ``` #### func (*GlBufferData) TypeID @@ -4726,10 +8724,11 @@ func (c *GlBufferData) TypeID() atom.TypeID ```go type GlBufferSubData struct { binary.Generate + Target BufferTarget Offset int32 Size int32 - Data memory.Pointer + Data Voidᵖ } ``` @@ -4740,12 +8739,7 @@ GlBufferSubData #### func NewGlBufferSubData ```go -func NewGlBufferSubData( - pTarget BufferTarget, - pOffset int32, - pSize int32, - pData memory.Pointer, -) *GlBufferSubData +func NewGlBufferSubData(Target BufferTarget, Offset int32, Size int32, Data memory.Pointer) *GlBufferSubData ``` #### func (*GlBufferSubData) API @@ -4754,6 +8748,22 @@ func NewGlBufferSubData( func (c *GlBufferSubData) API() gfxapi.API ``` +#### func (*GlBufferSubData) AddRead + +```go +func (a *GlBufferSubData) AddRead(rng memory.Range, id binary.ID) *GlBufferSubData +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlBufferSubData pointer is returned so that calls can be chained. + +#### func (*GlBufferSubData) AddWrite + +```go +func (a *GlBufferSubData) AddWrite(rng memory.Range, id binary.ID) *GlBufferSubData +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlBufferSubData pointer is returned so that calls can be chained. + #### func (*GlBufferSubData) Class ```go @@ -4769,19 +8779,25 @@ func (c *GlBufferSubData) Flags() atom.Flags #### func (*GlBufferSubData) Mutate ```go -func (ϟa *GlBufferSubData) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlBufferSubData) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlBufferSubData) Observations + +```go +func (a *GlBufferSubData) Observations() *atom.Observations ``` #### func (*GlBufferSubData) Replay ```go -func (ϟa *GlBufferSubData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlBufferSubData) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlBufferSubData) String ```go -func (c *GlBufferSubData) String() string +func (a *GlBufferSubData) String() string ``` #### func (*GlBufferSubData) TypeID @@ -4795,6 +8811,7 @@ func (c *GlBufferSubData) TypeID() atom.TypeID ```go type GlCheckFramebufferStatus struct { binary.Generate + Target FramebufferTarget Result FramebufferStatus } @@ -4807,10 +8824,7 @@ GlCheckFramebufferStatus #### func NewGlCheckFramebufferStatus ```go -func NewGlCheckFramebufferStatus( - pTarget FramebufferTarget, - pResult FramebufferStatus, -) *GlCheckFramebufferStatus +func NewGlCheckFramebufferStatus(Target FramebufferTarget, Result FramebufferStatus) *GlCheckFramebufferStatus ``` #### func (*GlCheckFramebufferStatus) API @@ -4819,55 +8833,64 @@ func NewGlCheckFramebufferStatus( func (c *GlCheckFramebufferStatus) API() gfxapi.API ``` -#### func (*GlCheckFramebufferStatus) Class +#### func (*GlCheckFramebufferStatus) AddRead ```go -func (*GlCheckFramebufferStatus) Class() binary.Class +func (a *GlCheckFramebufferStatus) AddRead(rng memory.Range, id binary.ID) *GlCheckFramebufferStatus ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCheckFramebufferStatus pointer is returned so that calls can be +chained. -#### func (*GlCheckFramebufferStatus) Flags +#### func (*GlCheckFramebufferStatus) AddWrite ```go -func (c *GlCheckFramebufferStatus) Flags() atom.Flags +func (a *GlCheckFramebufferStatus) AddWrite(rng memory.Range, id binary.ID) *GlCheckFramebufferStatus ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCheckFramebufferStatus pointer is returned so that calls can be +chained. -#### func (*GlCheckFramebufferStatus) Mutate +#### func (*GlCheckFramebufferStatus) Class ```go -func (ϟa *GlCheckFramebufferStatus) Mutate(ϟs *gfxapi.State) error +func (*GlCheckFramebufferStatus) Class() binary.Class ``` -#### func (*GlCheckFramebufferStatus) Replay +#### func (*GlCheckFramebufferStatus) Flags ```go -func (ϟa *GlCheckFramebufferStatus) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlCheckFramebufferStatus) Flags() atom.Flags ``` -#### func (*GlCheckFramebufferStatus) String +#### func (*GlCheckFramebufferStatus) Mutate ```go -func (c *GlCheckFramebufferStatus) String() string +func (ϟa *GlCheckFramebufferStatus) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlCheckFramebufferStatus) TypeID +#### func (*GlCheckFramebufferStatus) Observations ```go -func (c *GlCheckFramebufferStatus) TypeID() atom.TypeID +func (a *GlCheckFramebufferStatus) Observations() *atom.Observations ``` -#### type GlCheckFramebufferStatus_Postback +#### func (*GlCheckFramebufferStatus) Replay ```go -type GlCheckFramebufferStatus_Postback struct { - Result FramebufferStatus -} +func (ϟa *GlCheckFramebufferStatus) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlCheckFramebufferStatus) String -#### func (*GlCheckFramebufferStatus_Postback) Decode +```go +func (a *GlCheckFramebufferStatus) String() string +``` + +#### func (*GlCheckFramebufferStatus) TypeID ```go -func (o *GlCheckFramebufferStatus_Postback) Decode(d binary.Decoder) error +func (c *GlCheckFramebufferStatus) TypeID() atom.TypeID ``` #### type GlClear @@ -4875,6 +8898,7 @@ func (o *GlCheckFramebufferStatus_Postback) Decode(d binary.Decoder) error ```go type GlClear struct { binary.Generate + Mask ClearMask } ``` @@ -4886,9 +8910,7 @@ GlClear #### func NewGlClear ```go -func NewGlClear( - pMask ClearMask, -) *GlClear +func NewGlClear(Mask ClearMask) *GlClear ``` #### func (*GlClear) API @@ -4897,6 +8919,22 @@ func NewGlClear( func (c *GlClear) API() gfxapi.API ``` +#### func (*GlClear) AddRead + +```go +func (a *GlClear) AddRead(rng memory.Range, id binary.ID) *GlClear +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlClear pointer is returned so that calls can be chained. + +#### func (*GlClear) AddWrite + +```go +func (a *GlClear) AddWrite(rng memory.Range, id binary.ID) *GlClear +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlClear pointer is returned so that calls can be chained. + #### func (*GlClear) Class ```go @@ -4912,19 +8950,25 @@ func (c *GlClear) Flags() atom.Flags #### func (*GlClear) Mutate ```go -func (ϟa *GlClear) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlClear) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlClear) Observations + +```go +func (a *GlClear) Observations() *atom.Observations ``` #### func (*GlClear) Replay ```go -func (ϟa *GlClear) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlClear) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlClear) String ```go -func (c *GlClear) String() string +func (a *GlClear) String() string ``` #### func (*GlClear) TypeID @@ -4938,6 +8982,7 @@ func (c *GlClear) TypeID() atom.TypeID ```go type GlClearColor struct { binary.Generate + R float32 G float32 B float32 @@ -4952,12 +8997,7 @@ GlClearColor #### func NewGlClearColor ```go -func NewGlClearColor( - pR float32, - pG float32, - pB float32, - pA float32, -) *GlClearColor +func NewGlClearColor(R float32, G float32, B float32, A float32) *GlClearColor ``` #### func (*GlClearColor) API @@ -4966,6 +9006,22 @@ func NewGlClearColor( func (c *GlClearColor) API() gfxapi.API ``` +#### func (*GlClearColor) AddRead + +```go +func (a *GlClearColor) AddRead(rng memory.Range, id binary.ID) *GlClearColor +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlClearColor pointer is returned so that calls can be chained. + +#### func (*GlClearColor) AddWrite + +```go +func (a *GlClearColor) AddWrite(rng memory.Range, id binary.ID) *GlClearColor +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlClearColor pointer is returned so that calls can be chained. + #### func (*GlClearColor) Class ```go @@ -4981,19 +9037,25 @@ func (c *GlClearColor) Flags() atom.Flags #### func (*GlClearColor) Mutate ```go -func (ϟa *GlClearColor) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlClearColor) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlClearColor) Observations + +```go +func (a *GlClearColor) Observations() *atom.Observations ``` #### func (*GlClearColor) Replay ```go -func (ϟa *GlClearColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlClearColor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlClearColor) String ```go -func (c *GlClearColor) String() string +func (a *GlClearColor) String() string ``` #### func (*GlClearColor) TypeID @@ -5007,6 +9069,7 @@ func (c *GlClearColor) TypeID() atom.TypeID ```go type GlClearDepthf struct { binary.Generate + Depth float32 } ``` @@ -5018,9 +9081,7 @@ GlClearDepthf #### func NewGlClearDepthf ```go -func NewGlClearDepthf( - pDepth float32, -) *GlClearDepthf +func NewGlClearDepthf(Depth float32) *GlClearDepthf ``` #### func (*GlClearDepthf) API @@ -5029,6 +9090,22 @@ func NewGlClearDepthf( func (c *GlClearDepthf) API() gfxapi.API ``` +#### func (*GlClearDepthf) AddRead + +```go +func (a *GlClearDepthf) AddRead(rng memory.Range, id binary.ID) *GlClearDepthf +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlClearDepthf pointer is returned so that calls can be chained. + +#### func (*GlClearDepthf) AddWrite + +```go +func (a *GlClearDepthf) AddWrite(rng memory.Range, id binary.ID) *GlClearDepthf +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlClearDepthf pointer is returned so that calls can be chained. + #### func (*GlClearDepthf) Class ```go @@ -5044,19 +9121,25 @@ func (c *GlClearDepthf) Flags() atom.Flags #### func (*GlClearDepthf) Mutate ```go -func (ϟa *GlClearDepthf) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlClearDepthf) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlClearDepthf) Observations + +```go +func (a *GlClearDepthf) Observations() *atom.Observations ``` #### func (*GlClearDepthf) Replay ```go -func (ϟa *GlClearDepthf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlClearDepthf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlClearDepthf) String ```go -func (c *GlClearDepthf) String() string +func (a *GlClearDepthf) String() string ``` #### func (*GlClearDepthf) TypeID @@ -5070,6 +9153,7 @@ func (c *GlClearDepthf) TypeID() atom.TypeID ```go type GlClearStencil struct { binary.Generate + Stencil int32 } ``` @@ -5081,9 +9165,7 @@ GlClearStencil #### func NewGlClearStencil ```go -func NewGlClearStencil( - pStencil int32, -) *GlClearStencil +func NewGlClearStencil(Stencil int32) *GlClearStencil ``` #### func (*GlClearStencil) API @@ -5092,6 +9174,22 @@ func NewGlClearStencil( func (c *GlClearStencil) API() gfxapi.API ``` +#### func (*GlClearStencil) AddRead + +```go +func (a *GlClearStencil) AddRead(rng memory.Range, id binary.ID) *GlClearStencil +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlClearStencil pointer is returned so that calls can be chained. + +#### func (*GlClearStencil) AddWrite + +```go +func (a *GlClearStencil) AddWrite(rng memory.Range, id binary.ID) *GlClearStencil +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlClearStencil pointer is returned so that calls can be chained. + #### func (*GlClearStencil) Class ```go @@ -5107,19 +9205,25 @@ func (c *GlClearStencil) Flags() atom.Flags #### func (*GlClearStencil) Mutate ```go -func (ϟa *GlClearStencil) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlClearStencil) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlClearStencil) Observations + +```go +func (a *GlClearStencil) Observations() *atom.Observations ``` #### func (*GlClearStencil) Replay ```go -func (ϟa *GlClearStencil) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlClearStencil) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlClearStencil) String ```go -func (c *GlClearStencil) String() string +func (a *GlClearStencil) String() string ``` #### func (*GlClearStencil) TypeID @@ -5128,11 +9232,99 @@ func (c *GlClearStencil) String() string func (c *GlClearStencil) TypeID() atom.TypeID ``` +#### type GlClientWaitSync + +```go +type GlClientWaitSync struct { + binary.Generate + + Sync SyncObject + SyncFlags SyncFlags + Timeout uint64 + Result ClientWaitSyncSignal +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlClientWaitSync +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlClientWaitSync + +```go +func NewGlClientWaitSync(Sync SyncObject, SyncFlags SyncFlags, Timeout uint64, Result ClientWaitSyncSignal) *GlClientWaitSync +``` + +#### func (*GlClientWaitSync) API + +```go +func (c *GlClientWaitSync) API() gfxapi.API +``` + +#### func (*GlClientWaitSync) AddRead + +```go +func (a *GlClientWaitSync) AddRead(rng memory.Range, id binary.ID) *GlClientWaitSync +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlClientWaitSync pointer is returned so that calls can be chained. + +#### func (*GlClientWaitSync) AddWrite + +```go +func (a *GlClientWaitSync) AddWrite(rng memory.Range, id binary.ID) *GlClientWaitSync +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlClientWaitSync pointer is returned so that calls can be chained. + +#### func (*GlClientWaitSync) Class + +```go +func (*GlClientWaitSync) Class() binary.Class +``` + +#### func (*GlClientWaitSync) Flags + +```go +func (c *GlClientWaitSync) Flags() atom.Flags +``` + +#### func (*GlClientWaitSync) Mutate + +```go +func (ϟa *GlClientWaitSync) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlClientWaitSync) Observations + +```go +func (a *GlClientWaitSync) Observations() *atom.Observations +``` + +#### func (*GlClientWaitSync) Replay + +```go +func (ϟa *GlClientWaitSync) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlClientWaitSync) String + +```go +func (a *GlClientWaitSync) String() string +``` + +#### func (*GlClientWaitSync) TypeID + +```go +func (c *GlClientWaitSync) TypeID() atom.TypeID +``` + #### type GlColorMask ```go type GlColorMask struct { binary.Generate + Red bool Green bool Blue bool @@ -5147,12 +9339,7 @@ GlColorMask #### func NewGlColorMask ```go -func NewGlColorMask( - pRed bool, - pGreen bool, - pBlue bool, - pAlpha bool, -) *GlColorMask +func NewGlColorMask(Red bool, Green bool, Blue bool, Alpha bool) *GlColorMask ``` #### func (*GlColorMask) API @@ -5161,6 +9348,22 @@ func NewGlColorMask( func (c *GlColorMask) API() gfxapi.API ``` +#### func (*GlColorMask) AddRead + +```go +func (a *GlColorMask) AddRead(rng memory.Range, id binary.ID) *GlColorMask +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlColorMask pointer is returned so that calls can be chained. + +#### func (*GlColorMask) AddWrite + +```go +func (a *GlColorMask) AddWrite(rng memory.Range, id binary.ID) *GlColorMask +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlColorMask pointer is returned so that calls can be chained. + #### func (*GlColorMask) Class ```go @@ -5176,19 +9379,25 @@ func (c *GlColorMask) Flags() atom.Flags #### func (*GlColorMask) Mutate ```go -func (ϟa *GlColorMask) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlColorMask) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlColorMask) Observations + +```go +func (a *GlColorMask) Observations() *atom.Observations ``` #### func (*GlColorMask) Replay ```go -func (ϟa *GlColorMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlColorMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlColorMask) String ```go -func (c *GlColorMask) String() string +func (a *GlColorMask) String() string ``` #### func (*GlColorMask) TypeID @@ -5202,6 +9411,7 @@ func (c *GlColorMask) TypeID() atom.TypeID ```go type GlCompileShader struct { binary.Generate + Shader ShaderId } ``` @@ -5213,9 +9423,7 @@ GlCompileShader #### func NewGlCompileShader ```go -func NewGlCompileShader( - pShader ShaderId, -) *GlCompileShader +func NewGlCompileShader(Shader ShaderId) *GlCompileShader ``` #### func (*GlCompileShader) API @@ -5224,6 +9432,22 @@ func NewGlCompileShader( func (c *GlCompileShader) API() gfxapi.API ``` +#### func (*GlCompileShader) AddRead + +```go +func (a *GlCompileShader) AddRead(rng memory.Range, id binary.ID) *GlCompileShader +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCompileShader pointer is returned so that calls can be chained. + +#### func (*GlCompileShader) AddWrite + +```go +func (a *GlCompileShader) AddWrite(rng memory.Range, id binary.ID) *GlCompileShader +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCompileShader pointer is returned so that calls can be chained. + #### func (*GlCompileShader) Class ```go @@ -5239,19 +9463,25 @@ func (c *GlCompileShader) Flags() atom.Flags #### func (*GlCompileShader) Mutate ```go -func (ϟa *GlCompileShader) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCompileShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCompileShader) Observations + +```go +func (a *GlCompileShader) Observations() *atom.Observations ``` #### func (*GlCompileShader) Replay ```go -func (ϟa *GlCompileShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCompileShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCompileShader) String ```go -func (c *GlCompileShader) String() string +func (a *GlCompileShader) String() string ``` #### func (*GlCompileShader) TypeID @@ -5265,6 +9495,7 @@ func (c *GlCompileShader) TypeID() atom.TypeID ```go type GlCompressedTexImage2D struct { binary.Generate + Target TextureImageTarget Level int32 Format CompressedTexelFormat @@ -5283,16 +9514,7 @@ GlCompressedTexImage2D #### func NewGlCompressedTexImage2D ```go -func NewGlCompressedTexImage2D( - pTarget TextureImageTarget, - pLevel int32, - pFormat CompressedTexelFormat, - pWidth int32, - pHeight int32, - pBorder int32, - pImageSize int32, - pData TexturePointer, -) *GlCompressedTexImage2D +func NewGlCompressedTexImage2D(Target TextureImageTarget, Level int32, Format CompressedTexelFormat, Width int32, Height int32, Border int32, Image_size int32, Data memory.Pointer) *GlCompressedTexImage2D ``` #### func (*GlCompressedTexImage2D) API @@ -5301,6 +9523,24 @@ func NewGlCompressedTexImage2D( func (c *GlCompressedTexImage2D) API() gfxapi.API ``` +#### func (*GlCompressedTexImage2D) AddRead + +```go +func (a *GlCompressedTexImage2D) AddRead(rng memory.Range, id binary.ID) *GlCompressedTexImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCompressedTexImage2D pointer is returned so that calls can be +chained. + +#### func (*GlCompressedTexImage2D) AddWrite + +```go +func (a *GlCompressedTexImage2D) AddWrite(rng memory.Range, id binary.ID) *GlCompressedTexImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCompressedTexImage2D pointer is returned so that calls can be +chained. + #### func (*GlCompressedTexImage2D) Class ```go @@ -5316,19 +9556,25 @@ func (c *GlCompressedTexImage2D) Flags() atom.Flags #### func (*GlCompressedTexImage2D) Mutate ```go -func (ϟa *GlCompressedTexImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCompressedTexImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCompressedTexImage2D) Observations + +```go +func (a *GlCompressedTexImage2D) Observations() *atom.Observations ``` #### func (*GlCompressedTexImage2D) Replay ```go -func (ϟa *GlCompressedTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCompressedTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCompressedTexImage2D) String ```go -func (c *GlCompressedTexImage2D) String() string +func (a *GlCompressedTexImage2D) String() string ``` #### func (*GlCompressedTexImage2D) TypeID @@ -5342,6 +9588,7 @@ func (c *GlCompressedTexImage2D) TypeID() atom.TypeID ```go type GlCompressedTexSubImage2D struct { binary.Generate + Target TextureImageTarget Level int32 Xoffset int32 @@ -5361,17 +9608,7 @@ GlCompressedTexSubImage2D #### func NewGlCompressedTexSubImage2D ```go -func NewGlCompressedTexSubImage2D( - pTarget TextureImageTarget, - pLevel int32, - pXoffset int32, - pYoffset int32, - pWidth int32, - pHeight int32, - pFormat CompressedTexelFormat, - pImageSize int32, - pData TexturePointer, -) *GlCompressedTexSubImage2D +func NewGlCompressedTexSubImage2D(Target TextureImageTarget, Level int32, Xoffset int32, Yoffset int32, Width int32, Height int32, Format CompressedTexelFormat, Image_size int32, Data memory.Pointer) *GlCompressedTexSubImage2D ``` #### func (*GlCompressedTexSubImage2D) API @@ -5380,6 +9617,24 @@ func NewGlCompressedTexSubImage2D( func (c *GlCompressedTexSubImage2D) API() gfxapi.API ``` +#### func (*GlCompressedTexSubImage2D) AddRead + +```go +func (a *GlCompressedTexSubImage2D) AddRead(rng memory.Range, id binary.ID) *GlCompressedTexSubImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCompressedTexSubImage2D pointer is returned so that calls can be +chained. + +#### func (*GlCompressedTexSubImage2D) AddWrite + +```go +func (a *GlCompressedTexSubImage2D) AddWrite(rng memory.Range, id binary.ID) *GlCompressedTexSubImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCompressedTexSubImage2D pointer is returned so that calls can be +chained. + #### func (*GlCompressedTexSubImage2D) Class ```go @@ -5395,19 +9650,25 @@ func (c *GlCompressedTexSubImage2D) Flags() atom.Flags #### func (*GlCompressedTexSubImage2D) Mutate ```go -func (ϟa *GlCompressedTexSubImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCompressedTexSubImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCompressedTexSubImage2D) Observations + +```go +func (a *GlCompressedTexSubImage2D) Observations() *atom.Observations ``` #### func (*GlCompressedTexSubImage2D) Replay ```go -func (ϟa *GlCompressedTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCompressedTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCompressedTexSubImage2D) String ```go -func (c *GlCompressedTexSubImage2D) String() string +func (a *GlCompressedTexSubImage2D) String() string ``` #### func (*GlCompressedTexSubImage2D) TypeID @@ -5421,6 +9682,7 @@ func (c *GlCompressedTexSubImage2D) TypeID() atom.TypeID ```go type GlCopyTexImage2D struct { binary.Generate + Target TextureImageTarget Level int32 Format TexelFormat @@ -5439,16 +9701,7 @@ GlCopyTexImage2D #### func NewGlCopyTexImage2D ```go -func NewGlCopyTexImage2D( - pTarget TextureImageTarget, - pLevel int32, - pFormat TexelFormat, - pX int32, - pY int32, - pWidth int32, - pHeight int32, - pBorder int32, -) *GlCopyTexImage2D +func NewGlCopyTexImage2D(Target TextureImageTarget, Level int32, Format TexelFormat, X int32, Y int32, Width int32, Height int32, Border int32) *GlCopyTexImage2D ``` #### func (*GlCopyTexImage2D) API @@ -5457,6 +9710,22 @@ func NewGlCopyTexImage2D( func (c *GlCopyTexImage2D) API() gfxapi.API ``` +#### func (*GlCopyTexImage2D) AddRead + +```go +func (a *GlCopyTexImage2D) AddRead(rng memory.Range, id binary.ID) *GlCopyTexImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCopyTexImage2D pointer is returned so that calls can be chained. + +#### func (*GlCopyTexImage2D) AddWrite + +```go +func (a *GlCopyTexImage2D) AddWrite(rng memory.Range, id binary.ID) *GlCopyTexImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCopyTexImage2D pointer is returned so that calls can be chained. + #### func (*GlCopyTexImage2D) Class ```go @@ -5472,19 +9741,25 @@ func (c *GlCopyTexImage2D) Flags() atom.Flags #### func (*GlCopyTexImage2D) Mutate ```go -func (ϟa *GlCopyTexImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCopyTexImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCopyTexImage2D) Observations + +```go +func (a *GlCopyTexImage2D) Observations() *atom.Observations ``` #### func (*GlCopyTexImage2D) Replay ```go -func (ϟa *GlCopyTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCopyTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCopyTexImage2D) String ```go -func (c *GlCopyTexImage2D) String() string +func (a *GlCopyTexImage2D) String() string ``` #### func (*GlCopyTexImage2D) TypeID @@ -5498,6 +9773,7 @@ func (c *GlCopyTexImage2D) TypeID() atom.TypeID ```go type GlCopyTexSubImage2D struct { binary.Generate + Target TextureImageTarget Level int32 Xoffset int32 @@ -5516,16 +9792,7 @@ GlCopyTexSubImage2D #### func NewGlCopyTexSubImage2D ```go -func NewGlCopyTexSubImage2D( - pTarget TextureImageTarget, - pLevel int32, - pXoffset int32, - pYoffset int32, - pX int32, - pY int32, - pWidth int32, - pHeight int32, -) *GlCopyTexSubImage2D +func NewGlCopyTexSubImage2D(Target TextureImageTarget, Level int32, Xoffset int32, Yoffset int32, X int32, Y int32, Width int32, Height int32) *GlCopyTexSubImage2D ``` #### func (*GlCopyTexSubImage2D) API @@ -5534,6 +9801,24 @@ func NewGlCopyTexSubImage2D( func (c *GlCopyTexSubImage2D) API() gfxapi.API ``` +#### func (*GlCopyTexSubImage2D) AddRead + +```go +func (a *GlCopyTexSubImage2D) AddRead(rng memory.Range, id binary.ID) *GlCopyTexSubImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCopyTexSubImage2D pointer is returned so that calls can be +chained. + +#### func (*GlCopyTexSubImage2D) AddWrite + +```go +func (a *GlCopyTexSubImage2D) AddWrite(rng memory.Range, id binary.ID) *GlCopyTexSubImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCopyTexSubImage2D pointer is returned so that calls can be +chained. + #### func (*GlCopyTexSubImage2D) Class ```go @@ -5549,19 +9834,25 @@ func (c *GlCopyTexSubImage2D) Flags() atom.Flags #### func (*GlCopyTexSubImage2D) Mutate ```go -func (ϟa *GlCopyTexSubImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCopyTexSubImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCopyTexSubImage2D) Observations + +```go +func (a *GlCopyTexSubImage2D) Observations() *atom.Observations ``` #### func (*GlCopyTexSubImage2D) Replay ```go -func (ϟa *GlCopyTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCopyTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCopyTexSubImage2D) String ```go -func (c *GlCopyTexSubImage2D) String() string +func (a *GlCopyTexSubImage2D) String() string ``` #### func (*GlCopyTexSubImage2D) TypeID @@ -5575,6 +9866,7 @@ func (c *GlCopyTexSubImage2D) TypeID() atom.TypeID ```go type GlCreateProgram struct { binary.Generate + Result ProgramId } ``` @@ -5586,9 +9878,7 @@ GlCreateProgram #### func NewGlCreateProgram ```go -func NewGlCreateProgram( - pResult ProgramId, -) *GlCreateProgram +func NewGlCreateProgram(Result ProgramId) *GlCreateProgram ``` #### func (*GlCreateProgram) API @@ -5597,55 +9887,62 @@ func NewGlCreateProgram( func (c *GlCreateProgram) API() gfxapi.API ``` -#### func (*GlCreateProgram) Class +#### func (*GlCreateProgram) AddRead ```go -func (*GlCreateProgram) Class() binary.Class +func (a *GlCreateProgram) AddRead(rng memory.Range, id binary.ID) *GlCreateProgram ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCreateProgram pointer is returned so that calls can be chained. -#### func (*GlCreateProgram) Flags +#### func (*GlCreateProgram) AddWrite ```go -func (c *GlCreateProgram) Flags() atom.Flags +func (a *GlCreateProgram) AddWrite(rng memory.Range, id binary.ID) *GlCreateProgram ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCreateProgram pointer is returned so that calls can be chained. -#### func (*GlCreateProgram) Mutate +#### func (*GlCreateProgram) Class ```go -func (ϟa *GlCreateProgram) Mutate(ϟs *gfxapi.State) error +func (*GlCreateProgram) Class() binary.Class ``` -#### func (*GlCreateProgram) Replay +#### func (*GlCreateProgram) Flags ```go -func (ϟa *GlCreateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlCreateProgram) Flags() atom.Flags ``` -#### func (*GlCreateProgram) String +#### func (*GlCreateProgram) Mutate ```go -func (c *GlCreateProgram) String() string +func (ϟa *GlCreateProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlCreateProgram) TypeID +#### func (*GlCreateProgram) Observations ```go -func (c *GlCreateProgram) TypeID() atom.TypeID +func (a *GlCreateProgram) Observations() *atom.Observations ``` -#### type GlCreateProgram_Postback +#### func (*GlCreateProgram) Replay ```go -type GlCreateProgram_Postback struct { - Result ProgramId -} +func (ϟa *GlCreateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlCreateProgram) String -#### func (*GlCreateProgram_Postback) Decode +```go +func (a *GlCreateProgram) String() string +``` + +#### func (*GlCreateProgram) TypeID ```go -func (o *GlCreateProgram_Postback) Decode(d binary.Decoder) error +func (c *GlCreateProgram) TypeID() atom.TypeID ``` #### type GlCreateShader @@ -5653,6 +9950,7 @@ func (o *GlCreateProgram_Postback) Decode(d binary.Decoder) error ```go type GlCreateShader struct { binary.Generate + Type ShaderType Result ShaderId } @@ -5665,10 +9963,7 @@ GlCreateShader #### func NewGlCreateShader ```go -func NewGlCreateShader( - pType ShaderType, - pResult ShaderId, -) *GlCreateShader +func NewGlCreateShader(Type ShaderType, Result ShaderId) *GlCreateShader ``` #### func (*GlCreateShader) API @@ -5677,55 +9972,62 @@ func NewGlCreateShader( func (c *GlCreateShader) API() gfxapi.API ``` -#### func (*GlCreateShader) Class +#### func (*GlCreateShader) AddRead ```go -func (*GlCreateShader) Class() binary.Class +func (a *GlCreateShader) AddRead(rng memory.Range, id binary.ID) *GlCreateShader ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCreateShader pointer is returned so that calls can be chained. -#### func (*GlCreateShader) Flags +#### func (*GlCreateShader) AddWrite ```go -func (c *GlCreateShader) Flags() atom.Flags +func (a *GlCreateShader) AddWrite(rng memory.Range, id binary.ID) *GlCreateShader ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCreateShader pointer is returned so that calls can be chained. -#### func (*GlCreateShader) Mutate +#### func (*GlCreateShader) Class ```go -func (ϟa *GlCreateShader) Mutate(ϟs *gfxapi.State) error +func (*GlCreateShader) Class() binary.Class ``` -#### func (*GlCreateShader) Replay +#### func (*GlCreateShader) Flags ```go -func (ϟa *GlCreateShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlCreateShader) Flags() atom.Flags ``` -#### func (*GlCreateShader) String +#### func (*GlCreateShader) Mutate ```go -func (c *GlCreateShader) String() string +func (ϟa *GlCreateShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlCreateShader) TypeID +#### func (*GlCreateShader) Observations ```go -func (c *GlCreateShader) TypeID() atom.TypeID +func (a *GlCreateShader) Observations() *atom.Observations ``` -#### type GlCreateShader_Postback +#### func (*GlCreateShader) Replay ```go -type GlCreateShader_Postback struct { - Result ShaderId -} +func (ϟa *GlCreateShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlCreateShader) String -#### func (*GlCreateShader_Postback) Decode +```go +func (a *GlCreateShader) String() string +``` + +#### func (*GlCreateShader) TypeID ```go -func (o *GlCreateShader_Postback) Decode(d binary.Decoder) error +func (c *GlCreateShader) TypeID() atom.TypeID ``` #### type GlCullFace @@ -5733,6 +10035,7 @@ func (o *GlCreateShader_Postback) Decode(d binary.Decoder) error ```go type GlCullFace struct { binary.Generate + Mode FaceMode } ``` @@ -5744,9 +10047,7 @@ GlCullFace #### func NewGlCullFace ```go -func NewGlCullFace( - pMode FaceMode, -) *GlCullFace +func NewGlCullFace(Mode FaceMode) *GlCullFace ``` #### func (*GlCullFace) API @@ -5755,6 +10056,22 @@ func NewGlCullFace( func (c *GlCullFace) API() gfxapi.API ``` +#### func (*GlCullFace) AddRead + +```go +func (a *GlCullFace) AddRead(rng memory.Range, id binary.ID) *GlCullFace +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlCullFace pointer is returned so that calls can be chained. + +#### func (*GlCullFace) AddWrite + +```go +func (a *GlCullFace) AddWrite(rng memory.Range, id binary.ID) *GlCullFace +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlCullFace pointer is returned so that calls can be chained. + #### func (*GlCullFace) Class ```go @@ -5770,19 +10087,25 @@ func (c *GlCullFace) Flags() atom.Flags #### func (*GlCullFace) Mutate ```go -func (ϟa *GlCullFace) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlCullFace) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlCullFace) Observations + +```go +func (a *GlCullFace) Observations() *atom.Observations ``` #### func (*GlCullFace) Replay ```go -func (ϟa *GlCullFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlCullFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlCullFace) String ```go -func (c *GlCullFace) String() string +func (a *GlCullFace) String() string ``` #### func (*GlCullFace) TypeID @@ -5796,8 +10119,9 @@ func (c *GlCullFace) TypeID() atom.TypeID ```go type GlDeleteBuffers struct { binary.Generate + Count int32 - Buffers BufferIdArray + Buffers BufferIdᵖ } ``` @@ -5808,10 +10132,7 @@ GlDeleteBuffers #### func NewGlDeleteBuffers ```go -func NewGlDeleteBuffers( - pCount int32, - pBuffers BufferIdArray, -) *GlDeleteBuffers +func NewGlDeleteBuffers(Count int32, Buffers memory.Pointer) *GlDeleteBuffers ``` #### func (*GlDeleteBuffers) API @@ -5820,6 +10141,22 @@ func NewGlDeleteBuffers( func (c *GlDeleteBuffers) API() gfxapi.API ``` +#### func (*GlDeleteBuffers) AddRead + +```go +func (a *GlDeleteBuffers) AddRead(rng memory.Range, id binary.ID) *GlDeleteBuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteBuffers pointer is returned so that calls can be chained. + +#### func (*GlDeleteBuffers) AddWrite + +```go +func (a *GlDeleteBuffers) AddWrite(rng memory.Range, id binary.ID) *GlDeleteBuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteBuffers pointer is returned so that calls can be chained. + #### func (*GlDeleteBuffers) Class ```go @@ -5835,19 +10172,25 @@ func (c *GlDeleteBuffers) Flags() atom.Flags #### func (*GlDeleteBuffers) Mutate ```go -func (ϟa *GlDeleteBuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteBuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteBuffers) Observations + +```go +func (a *GlDeleteBuffers) Observations() *atom.Observations ``` #### func (*GlDeleteBuffers) Replay ```go -func (ϟa *GlDeleteBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteBuffers) String ```go -func (c *GlDeleteBuffers) String() string +func (a *GlDeleteBuffers) String() string ``` #### func (*GlDeleteBuffers) TypeID @@ -5861,8 +10204,9 @@ func (c *GlDeleteBuffers) TypeID() atom.TypeID ```go type GlDeleteFramebuffers struct { binary.Generate + Count int32 - Framebuffers FramebufferIdArray + Framebuffers FramebufferIdᵖ } ``` @@ -5873,10 +10217,7 @@ GlDeleteFramebuffers #### func NewGlDeleteFramebuffers ```go -func NewGlDeleteFramebuffers( - pCount int32, - pFramebuffers FramebufferIdArray, -) *GlDeleteFramebuffers +func NewGlDeleteFramebuffers(Count int32, Framebuffers memory.Pointer) *GlDeleteFramebuffers ``` #### func (*GlDeleteFramebuffers) API @@ -5885,6 +10226,24 @@ func NewGlDeleteFramebuffers( func (c *GlDeleteFramebuffers) API() gfxapi.API ``` +#### func (*GlDeleteFramebuffers) AddRead + +```go +func (a *GlDeleteFramebuffers) AddRead(rng memory.Range, id binary.ID) *GlDeleteFramebuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteFramebuffers pointer is returned so that calls can be +chained. + +#### func (*GlDeleteFramebuffers) AddWrite + +```go +func (a *GlDeleteFramebuffers) AddWrite(rng memory.Range, id binary.ID) *GlDeleteFramebuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteFramebuffers pointer is returned so that calls can be +chained. + #### func (*GlDeleteFramebuffers) Class ```go @@ -5900,19 +10259,25 @@ func (c *GlDeleteFramebuffers) Flags() atom.Flags #### func (*GlDeleteFramebuffers) Mutate ```go -func (ϟa *GlDeleteFramebuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteFramebuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteFramebuffers) Observations + +```go +func (a *GlDeleteFramebuffers) Observations() *atom.Observations ``` #### func (*GlDeleteFramebuffers) Replay ```go -func (ϟa *GlDeleteFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteFramebuffers) String ```go -func (c *GlDeleteFramebuffers) String() string +func (a *GlDeleteFramebuffers) String() string ``` #### func (*GlDeleteFramebuffers) TypeID @@ -5926,6 +10291,7 @@ func (c *GlDeleteFramebuffers) TypeID() atom.TypeID ```go type GlDeleteProgram struct { binary.Generate + Program ProgramId } ``` @@ -5937,9 +10303,7 @@ GlDeleteProgram #### func NewGlDeleteProgram ```go -func NewGlDeleteProgram( - pProgram ProgramId, -) *GlDeleteProgram +func NewGlDeleteProgram(Program ProgramId) *GlDeleteProgram ``` #### func (*GlDeleteProgram) API @@ -5948,6 +10312,22 @@ func NewGlDeleteProgram( func (c *GlDeleteProgram) API() gfxapi.API ``` +#### func (*GlDeleteProgram) AddRead + +```go +func (a *GlDeleteProgram) AddRead(rng memory.Range, id binary.ID) *GlDeleteProgram +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteProgram pointer is returned so that calls can be chained. + +#### func (*GlDeleteProgram) AddWrite + +```go +func (a *GlDeleteProgram) AddWrite(rng memory.Range, id binary.ID) *GlDeleteProgram +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteProgram pointer is returned so that calls can be chained. + #### func (*GlDeleteProgram) Class ```go @@ -5963,19 +10343,25 @@ func (c *GlDeleteProgram) Flags() atom.Flags #### func (*GlDeleteProgram) Mutate ```go -func (ϟa *GlDeleteProgram) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteProgram) Observations + +```go +func (a *GlDeleteProgram) Observations() *atom.Observations ``` #### func (*GlDeleteProgram) Replay ```go -func (ϟa *GlDeleteProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteProgram) String ```go -func (c *GlDeleteProgram) String() string +func (a *GlDeleteProgram) String() string ``` #### func (*GlDeleteProgram) TypeID @@ -5989,8 +10375,9 @@ func (c *GlDeleteProgram) TypeID() atom.TypeID ```go type GlDeleteQueries struct { binary.Generate + Count int32 - Queries QueryIdArray + Queries QueryIdᵖ } ``` @@ -6001,10 +10388,7 @@ GlDeleteQueries #### func NewGlDeleteQueries ```go -func NewGlDeleteQueries( - pCount int32, - pQueries QueryIdArray, -) *GlDeleteQueries +func NewGlDeleteQueries(Count int32, Queries memory.Pointer) *GlDeleteQueries ``` #### func (*GlDeleteQueries) API @@ -6013,6 +10397,22 @@ func NewGlDeleteQueries( func (c *GlDeleteQueries) API() gfxapi.API ``` +#### func (*GlDeleteQueries) AddRead + +```go +func (a *GlDeleteQueries) AddRead(rng memory.Range, id binary.ID) *GlDeleteQueries +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteQueries pointer is returned so that calls can be chained. + +#### func (*GlDeleteQueries) AddWrite + +```go +func (a *GlDeleteQueries) AddWrite(rng memory.Range, id binary.ID) *GlDeleteQueries +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteQueries pointer is returned so that calls can be chained. + #### func (*GlDeleteQueries) Class ```go @@ -6028,19 +10428,25 @@ func (c *GlDeleteQueries) Flags() atom.Flags #### func (*GlDeleteQueries) Mutate ```go -func (ϟa *GlDeleteQueries) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteQueries) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteQueries) Observations + +```go +func (a *GlDeleteQueries) Observations() *atom.Observations ``` #### func (*GlDeleteQueries) Replay ```go -func (ϟa *GlDeleteQueries) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteQueries) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteQueries) String ```go -func (c *GlDeleteQueries) String() string +func (a *GlDeleteQueries) String() string ``` #### func (*GlDeleteQueries) TypeID @@ -6054,8 +10460,9 @@ func (c *GlDeleteQueries) TypeID() atom.TypeID ```go type GlDeleteQueriesEXT struct { binary.Generate + Count int32 - Queries QueryIdArray + Queries QueryIdᵖ } ``` @@ -6066,10 +10473,7 @@ GlDeleteQueriesEXT #### func NewGlDeleteQueriesEXT ```go -func NewGlDeleteQueriesEXT( - pCount int32, - pQueries QueryIdArray, -) *GlDeleteQueriesEXT +func NewGlDeleteQueriesEXT(Count int32, Queries memory.Pointer) *GlDeleteQueriesEXT ``` #### func (*GlDeleteQueriesEXT) API @@ -6078,6 +10482,24 @@ func NewGlDeleteQueriesEXT( func (c *GlDeleteQueriesEXT) API() gfxapi.API ``` +#### func (*GlDeleteQueriesEXT) AddRead + +```go +func (a *GlDeleteQueriesEXT) AddRead(rng memory.Range, id binary.ID) *GlDeleteQueriesEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteQueriesEXT pointer is returned so that calls can be +chained. + +#### func (*GlDeleteQueriesEXT) AddWrite + +```go +func (a *GlDeleteQueriesEXT) AddWrite(rng memory.Range, id binary.ID) *GlDeleteQueriesEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteQueriesEXT pointer is returned so that calls can be +chained. + #### func (*GlDeleteQueriesEXT) Class ```go @@ -6093,19 +10515,25 @@ func (c *GlDeleteQueriesEXT) Flags() atom.Flags #### func (*GlDeleteQueriesEXT) Mutate ```go -func (ϟa *GlDeleteQueriesEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteQueriesEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteQueriesEXT) Observations + +```go +func (a *GlDeleteQueriesEXT) Observations() *atom.Observations ``` #### func (*GlDeleteQueriesEXT) Replay ```go -func (ϟa *GlDeleteQueriesEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteQueriesEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteQueriesEXT) String ```go -func (c *GlDeleteQueriesEXT) String() string +func (a *GlDeleteQueriesEXT) String() string ``` #### func (*GlDeleteQueriesEXT) TypeID @@ -6119,8 +10547,9 @@ func (c *GlDeleteQueriesEXT) TypeID() atom.TypeID ```go type GlDeleteRenderbuffers struct { binary.Generate + Count int32 - Renderbuffers RenderbufferIdArray + Renderbuffers RenderbufferIdᵖ } ``` @@ -6131,10 +10560,7 @@ GlDeleteRenderbuffers #### func NewGlDeleteRenderbuffers ```go -func NewGlDeleteRenderbuffers( - pCount int32, - pRenderbuffers RenderbufferIdArray, -) *GlDeleteRenderbuffers +func NewGlDeleteRenderbuffers(Count int32, Renderbuffers memory.Pointer) *GlDeleteRenderbuffers ``` #### func (*GlDeleteRenderbuffers) API @@ -6143,6 +10569,24 @@ func NewGlDeleteRenderbuffers( func (c *GlDeleteRenderbuffers) API() gfxapi.API ``` +#### func (*GlDeleteRenderbuffers) AddRead + +```go +func (a *GlDeleteRenderbuffers) AddRead(rng memory.Range, id binary.ID) *GlDeleteRenderbuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteRenderbuffers pointer is returned so that calls can be +chained. + +#### func (*GlDeleteRenderbuffers) AddWrite + +```go +func (a *GlDeleteRenderbuffers) AddWrite(rng memory.Range, id binary.ID) *GlDeleteRenderbuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteRenderbuffers pointer is returned so that calls can be +chained. + #### func (*GlDeleteRenderbuffers) Class ```go @@ -6158,19 +10602,25 @@ func (c *GlDeleteRenderbuffers) Flags() atom.Flags #### func (*GlDeleteRenderbuffers) Mutate ```go -func (ϟa *GlDeleteRenderbuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteRenderbuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteRenderbuffers) Observations + +```go +func (a *GlDeleteRenderbuffers) Observations() *atom.Observations ``` #### func (*GlDeleteRenderbuffers) Replay ```go -func (ϟa *GlDeleteRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteRenderbuffers) String ```go -func (c *GlDeleteRenderbuffers) String() string +func (a *GlDeleteRenderbuffers) String() string ``` #### func (*GlDeleteRenderbuffers) TypeID @@ -6184,6 +10634,7 @@ func (c *GlDeleteRenderbuffers) TypeID() atom.TypeID ```go type GlDeleteShader struct { binary.Generate + Shader ShaderId } ``` @@ -6195,9 +10646,7 @@ GlDeleteShader #### func NewGlDeleteShader ```go -func NewGlDeleteShader( - pShader ShaderId, -) *GlDeleteShader +func NewGlDeleteShader(Shader ShaderId) *GlDeleteShader ``` #### func (*GlDeleteShader) API @@ -6206,6 +10655,22 @@ func NewGlDeleteShader( func (c *GlDeleteShader) API() gfxapi.API ``` +#### func (*GlDeleteShader) AddRead + +```go +func (a *GlDeleteShader) AddRead(rng memory.Range, id binary.ID) *GlDeleteShader +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteShader pointer is returned so that calls can be chained. + +#### func (*GlDeleteShader) AddWrite + +```go +func (a *GlDeleteShader) AddWrite(rng memory.Range, id binary.ID) *GlDeleteShader +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteShader pointer is returned so that calls can be chained. + #### func (*GlDeleteShader) Class ```go @@ -6221,19 +10686,25 @@ func (c *GlDeleteShader) Flags() atom.Flags #### func (*GlDeleteShader) Mutate ```go -func (ϟa *GlDeleteShader) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteShader) Observations + +```go +func (a *GlDeleteShader) Observations() *atom.Observations ``` #### func (*GlDeleteShader) Replay ```go -func (ϟa *GlDeleteShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteShader) String ```go -func (c *GlDeleteShader) String() string +func (a *GlDeleteShader) String() string ``` #### func (*GlDeleteShader) TypeID @@ -6242,13 +10713,98 @@ func (c *GlDeleteShader) String() string func (c *GlDeleteShader) TypeID() atom.TypeID ``` +#### type GlDeleteSync + +```go +type GlDeleteSync struct { + binary.Generate + + Sync SyncObject +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlDeleteSync +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlDeleteSync + +```go +func NewGlDeleteSync(Sync SyncObject) *GlDeleteSync +``` + +#### func (*GlDeleteSync) API + +```go +func (c *GlDeleteSync) API() gfxapi.API +``` + +#### func (*GlDeleteSync) AddRead + +```go +func (a *GlDeleteSync) AddRead(rng memory.Range, id binary.ID) *GlDeleteSync +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteSync pointer is returned so that calls can be chained. + +#### func (*GlDeleteSync) AddWrite + +```go +func (a *GlDeleteSync) AddWrite(rng memory.Range, id binary.ID) *GlDeleteSync +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteSync pointer is returned so that calls can be chained. + +#### func (*GlDeleteSync) Class + +```go +func (*GlDeleteSync) Class() binary.Class +``` + +#### func (*GlDeleteSync) Flags + +```go +func (c *GlDeleteSync) Flags() atom.Flags +``` + +#### func (*GlDeleteSync) Mutate + +```go +func (ϟa *GlDeleteSync) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteSync) Observations + +```go +func (a *GlDeleteSync) Observations() *atom.Observations +``` + +#### func (*GlDeleteSync) Replay + +```go +func (ϟa *GlDeleteSync) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlDeleteSync) String + +```go +func (a *GlDeleteSync) String() string +``` + +#### func (*GlDeleteSync) TypeID + +```go +func (c *GlDeleteSync) TypeID() atom.TypeID +``` + #### type GlDeleteTextures ```go type GlDeleteTextures struct { binary.Generate + Count int32 - Textures TextureIdArray + Textures TextureIdᵖ } ``` @@ -6259,10 +10815,7 @@ GlDeleteTextures #### func NewGlDeleteTextures ```go -func NewGlDeleteTextures( - pCount int32, - pTextures TextureIdArray, -) *GlDeleteTextures +func NewGlDeleteTextures(Count int32, Textures memory.Pointer) *GlDeleteTextures ``` #### func (*GlDeleteTextures) API @@ -6271,6 +10824,22 @@ func NewGlDeleteTextures( func (c *GlDeleteTextures) API() gfxapi.API ``` +#### func (*GlDeleteTextures) AddRead + +```go +func (a *GlDeleteTextures) AddRead(rng memory.Range, id binary.ID) *GlDeleteTextures +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteTextures pointer is returned so that calls can be chained. + +#### func (*GlDeleteTextures) AddWrite + +```go +func (a *GlDeleteTextures) AddWrite(rng memory.Range, id binary.ID) *GlDeleteTextures +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteTextures pointer is returned so that calls can be chained. + #### func (*GlDeleteTextures) Class ```go @@ -6286,19 +10855,25 @@ func (c *GlDeleteTextures) Flags() atom.Flags #### func (*GlDeleteTextures) Mutate ```go -func (ϟa *GlDeleteTextures) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteTextures) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteTextures) Observations + +```go +func (a *GlDeleteTextures) Observations() *atom.Observations ``` #### func (*GlDeleteTextures) Replay ```go -func (ϟa *GlDeleteTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteTextures) String ```go -func (c *GlDeleteTextures) String() string +func (a *GlDeleteTextures) String() string ``` #### func (*GlDeleteTextures) TypeID @@ -6307,13 +10882,101 @@ func (c *GlDeleteTextures) String() string func (c *GlDeleteTextures) TypeID() atom.TypeID ``` +#### type GlDeleteVertexArrays + +```go +type GlDeleteVertexArrays struct { + binary.Generate + + Count uint32 + Arrays VertexArrayIdᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlDeleteVertexArrays +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlDeleteVertexArrays + +```go +func NewGlDeleteVertexArrays(Count uint32, Arrays memory.Pointer) *GlDeleteVertexArrays +``` + +#### func (*GlDeleteVertexArrays) API + +```go +func (c *GlDeleteVertexArrays) API() gfxapi.API +``` + +#### func (*GlDeleteVertexArrays) AddRead + +```go +func (a *GlDeleteVertexArrays) AddRead(rng memory.Range, id binary.ID) *GlDeleteVertexArrays +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteVertexArrays pointer is returned so that calls can be +chained. + +#### func (*GlDeleteVertexArrays) AddWrite + +```go +func (a *GlDeleteVertexArrays) AddWrite(rng memory.Range, id binary.ID) *GlDeleteVertexArrays +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteVertexArrays pointer is returned so that calls can be +chained. + +#### func (*GlDeleteVertexArrays) Class + +```go +func (*GlDeleteVertexArrays) Class() binary.Class +``` + +#### func (*GlDeleteVertexArrays) Flags + +```go +func (c *GlDeleteVertexArrays) Flags() atom.Flags +``` + +#### func (*GlDeleteVertexArrays) Mutate + +```go +func (ϟa *GlDeleteVertexArrays) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteVertexArrays) Observations + +```go +func (a *GlDeleteVertexArrays) Observations() *atom.Observations +``` + +#### func (*GlDeleteVertexArrays) Replay + +```go +func (ϟa *GlDeleteVertexArrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlDeleteVertexArrays) String + +```go +func (a *GlDeleteVertexArrays) String() string +``` + +#### func (*GlDeleteVertexArrays) TypeID + +```go +func (c *GlDeleteVertexArrays) TypeID() atom.TypeID +``` + #### type GlDeleteVertexArraysOES ```go type GlDeleteVertexArraysOES struct { binary.Generate + Count int32 - Arrays VertexArrayIdArray + Arrays VertexArrayIdᵖ } ``` @@ -6324,10 +10987,7 @@ GlDeleteVertexArraysOES #### func NewGlDeleteVertexArraysOES ```go -func NewGlDeleteVertexArraysOES( - pCount int32, - pArrays VertexArrayIdArray, -) *GlDeleteVertexArraysOES +func NewGlDeleteVertexArraysOES(Count int32, Arrays memory.Pointer) *GlDeleteVertexArraysOES ``` #### func (*GlDeleteVertexArraysOES) API @@ -6336,6 +10996,24 @@ func NewGlDeleteVertexArraysOES( func (c *GlDeleteVertexArraysOES) API() gfxapi.API ``` +#### func (*GlDeleteVertexArraysOES) AddRead + +```go +func (a *GlDeleteVertexArraysOES) AddRead(rng memory.Range, id binary.ID) *GlDeleteVertexArraysOES +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDeleteVertexArraysOES pointer is returned so that calls can be +chained. + +#### func (*GlDeleteVertexArraysOES) AddWrite + +```go +func (a *GlDeleteVertexArraysOES) AddWrite(rng memory.Range, id binary.ID) *GlDeleteVertexArraysOES +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDeleteVertexArraysOES pointer is returned so that calls can be +chained. + #### func (*GlDeleteVertexArraysOES) Class ```go @@ -6351,19 +11029,25 @@ func (c *GlDeleteVertexArraysOES) Flags() atom.Flags #### func (*GlDeleteVertexArraysOES) Mutate ```go -func (ϟa *GlDeleteVertexArraysOES) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDeleteVertexArraysOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDeleteVertexArraysOES) Observations + +```go +func (a *GlDeleteVertexArraysOES) Observations() *atom.Observations ``` #### func (*GlDeleteVertexArraysOES) Replay ```go -func (ϟa *GlDeleteVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDeleteVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDeleteVertexArraysOES) String ```go -func (c *GlDeleteVertexArraysOES) String() string +func (a *GlDeleteVertexArraysOES) String() string ``` #### func (*GlDeleteVertexArraysOES) TypeID @@ -6377,6 +11061,7 @@ func (c *GlDeleteVertexArraysOES) TypeID() atom.TypeID ```go type GlDepthFunc struct { binary.Generate + Function TestFunction } ``` @@ -6388,9 +11073,7 @@ GlDepthFunc #### func NewGlDepthFunc ```go -func NewGlDepthFunc( - pFunction TestFunction, -) *GlDepthFunc +func NewGlDepthFunc(Function TestFunction) *GlDepthFunc ``` #### func (*GlDepthFunc) API @@ -6399,6 +11082,22 @@ func NewGlDepthFunc( func (c *GlDepthFunc) API() gfxapi.API ``` +#### func (*GlDepthFunc) AddRead + +```go +func (a *GlDepthFunc) AddRead(rng memory.Range, id binary.ID) *GlDepthFunc +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDepthFunc pointer is returned so that calls can be chained. + +#### func (*GlDepthFunc) AddWrite + +```go +func (a *GlDepthFunc) AddWrite(rng memory.Range, id binary.ID) *GlDepthFunc +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDepthFunc pointer is returned so that calls can be chained. + #### func (*GlDepthFunc) Class ```go @@ -6414,19 +11113,25 @@ func (c *GlDepthFunc) Flags() atom.Flags #### func (*GlDepthFunc) Mutate ```go -func (ϟa *GlDepthFunc) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDepthFunc) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDepthFunc) Observations + +```go +func (a *GlDepthFunc) Observations() *atom.Observations ``` #### func (*GlDepthFunc) Replay ```go -func (ϟa *GlDepthFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDepthFunc) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDepthFunc) String ```go -func (c *GlDepthFunc) String() string +func (a *GlDepthFunc) String() string ``` #### func (*GlDepthFunc) TypeID @@ -6440,6 +11145,7 @@ func (c *GlDepthFunc) TypeID() atom.TypeID ```go type GlDepthMask struct { binary.Generate + Enabled bool } ``` @@ -6451,9 +11157,7 @@ GlDepthMask #### func NewGlDepthMask ```go -func NewGlDepthMask( - pEnabled bool, -) *GlDepthMask +func NewGlDepthMask(Enabled bool) *GlDepthMask ``` #### func (*GlDepthMask) API @@ -6462,6 +11166,22 @@ func NewGlDepthMask( func (c *GlDepthMask) API() gfxapi.API ``` +#### func (*GlDepthMask) AddRead + +```go +func (a *GlDepthMask) AddRead(rng memory.Range, id binary.ID) *GlDepthMask +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDepthMask pointer is returned so that calls can be chained. + +#### func (*GlDepthMask) AddWrite + +```go +func (a *GlDepthMask) AddWrite(rng memory.Range, id binary.ID) *GlDepthMask +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDepthMask pointer is returned so that calls can be chained. + #### func (*GlDepthMask) Class ```go @@ -6477,19 +11197,25 @@ func (c *GlDepthMask) Flags() atom.Flags #### func (*GlDepthMask) Mutate ```go -func (ϟa *GlDepthMask) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDepthMask) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDepthMask) Observations + +```go +func (a *GlDepthMask) Observations() *atom.Observations ``` #### func (*GlDepthMask) Replay ```go -func (ϟa *GlDepthMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDepthMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDepthMask) String ```go -func (c *GlDepthMask) String() string +func (a *GlDepthMask) String() string ``` #### func (*GlDepthMask) TypeID @@ -6503,6 +11229,7 @@ func (c *GlDepthMask) TypeID() atom.TypeID ```go type GlDepthRangef struct { binary.Generate + Near float32 Far float32 } @@ -6515,10 +11242,7 @@ GlDepthRangef #### func NewGlDepthRangef ```go -func NewGlDepthRangef( - pNear float32, - pFar float32, -) *GlDepthRangef +func NewGlDepthRangef(Near float32, Far float32) *GlDepthRangef ``` #### func (*GlDepthRangef) API @@ -6527,6 +11251,22 @@ func NewGlDepthRangef( func (c *GlDepthRangef) API() gfxapi.API ``` +#### func (*GlDepthRangef) AddRead + +```go +func (a *GlDepthRangef) AddRead(rng memory.Range, id binary.ID) *GlDepthRangef +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDepthRangef pointer is returned so that calls can be chained. + +#### func (*GlDepthRangef) AddWrite + +```go +func (a *GlDepthRangef) AddWrite(rng memory.Range, id binary.ID) *GlDepthRangef +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDepthRangef pointer is returned so that calls can be chained. + #### func (*GlDepthRangef) Class ```go @@ -6542,19 +11282,25 @@ func (c *GlDepthRangef) Flags() atom.Flags #### func (*GlDepthRangef) Mutate ```go -func (ϟa *GlDepthRangef) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDepthRangef) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDepthRangef) Observations + +```go +func (a *GlDepthRangef) Observations() *atom.Observations ``` #### func (*GlDepthRangef) Replay ```go -func (ϟa *GlDepthRangef) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDepthRangef) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDepthRangef) String ```go -func (c *GlDepthRangef) String() string +func (a *GlDepthRangef) String() string ``` #### func (*GlDepthRangef) TypeID @@ -6568,6 +11314,7 @@ func (c *GlDepthRangef) TypeID() atom.TypeID ```go type GlDetachShader struct { binary.Generate + Program ProgramId Shader ShaderId } @@ -6580,10 +11327,7 @@ GlDetachShader #### func NewGlDetachShader ```go -func NewGlDetachShader( - pProgram ProgramId, - pShader ShaderId, -) *GlDetachShader +func NewGlDetachShader(Program ProgramId, Shader ShaderId) *GlDetachShader ``` #### func (*GlDetachShader) API @@ -6592,6 +11336,22 @@ func NewGlDetachShader( func (c *GlDetachShader) API() gfxapi.API ``` +#### func (*GlDetachShader) AddRead + +```go +func (a *GlDetachShader) AddRead(rng memory.Range, id binary.ID) *GlDetachShader +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDetachShader pointer is returned so that calls can be chained. + +#### func (*GlDetachShader) AddWrite + +```go +func (a *GlDetachShader) AddWrite(rng memory.Range, id binary.ID) *GlDetachShader +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDetachShader pointer is returned so that calls can be chained. + #### func (*GlDetachShader) Class ```go @@ -6607,19 +11367,25 @@ func (c *GlDetachShader) Flags() atom.Flags #### func (*GlDetachShader) Mutate ```go -func (ϟa *GlDetachShader) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDetachShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDetachShader) Observations + +```go +func (a *GlDetachShader) Observations() *atom.Observations ``` #### func (*GlDetachShader) Replay ```go -func (ϟa *GlDetachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDetachShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDetachShader) String ```go -func (c *GlDetachShader) String() string +func (a *GlDetachShader) String() string ``` #### func (*GlDetachShader) TypeID @@ -6633,6 +11399,7 @@ func (c *GlDetachShader) TypeID() atom.TypeID ```go type GlDisable struct { binary.Generate + Capability Capability } ``` @@ -6644,9 +11411,7 @@ GlDisable #### func NewGlDisable ```go -func NewGlDisable( - pCapability Capability, -) *GlDisable +func NewGlDisable(Capability Capability) *GlDisable ``` #### func (*GlDisable) API @@ -6655,6 +11420,22 @@ func NewGlDisable( func (c *GlDisable) API() gfxapi.API ``` +#### func (*GlDisable) AddRead + +```go +func (a *GlDisable) AddRead(rng memory.Range, id binary.ID) *GlDisable +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDisable pointer is returned so that calls can be chained. + +#### func (*GlDisable) AddWrite + +```go +func (a *GlDisable) AddWrite(rng memory.Range, id binary.ID) *GlDisable +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDisable pointer is returned so that calls can be chained. + #### func (*GlDisable) Class ```go @@ -6670,19 +11451,25 @@ func (c *GlDisable) Flags() atom.Flags #### func (*GlDisable) Mutate ```go -func (ϟa *GlDisable) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDisable) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDisable) Observations + +```go +func (a *GlDisable) Observations() *atom.Observations ``` #### func (*GlDisable) Replay ```go -func (ϟa *GlDisable) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDisable) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDisable) String ```go -func (c *GlDisable) String() string +func (a *GlDisable) String() string ``` #### func (*GlDisable) TypeID @@ -6696,6 +11483,7 @@ func (c *GlDisable) TypeID() atom.TypeID ```go type GlDisableClientState struct { binary.Generate + Type ArrayType } ``` @@ -6707,9 +11495,7 @@ GlDisableClientState #### func NewGlDisableClientState ```go -func NewGlDisableClientState( - pType ArrayType, -) *GlDisableClientState +func NewGlDisableClientState(Type ArrayType) *GlDisableClientState ``` #### func (*GlDisableClientState) API @@ -6718,6 +11504,24 @@ func NewGlDisableClientState( func (c *GlDisableClientState) API() gfxapi.API ``` +#### func (*GlDisableClientState) AddRead + +```go +func (a *GlDisableClientState) AddRead(rng memory.Range, id binary.ID) *GlDisableClientState +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDisableClientState pointer is returned so that calls can be +chained. + +#### func (*GlDisableClientState) AddWrite + +```go +func (a *GlDisableClientState) AddWrite(rng memory.Range, id binary.ID) *GlDisableClientState +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDisableClientState pointer is returned so that calls can be +chained. + #### func (*GlDisableClientState) Class ```go @@ -6733,19 +11537,25 @@ func (c *GlDisableClientState) Flags() atom.Flags #### func (*GlDisableClientState) Mutate ```go -func (ϟa *GlDisableClientState) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDisableClientState) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDisableClientState) Observations + +```go +func (a *GlDisableClientState) Observations() *atom.Observations ``` #### func (*GlDisableClientState) Replay ```go -func (ϟa *GlDisableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDisableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDisableClientState) String ```go -func (c *GlDisableClientState) String() string +func (a *GlDisableClientState) String() string ``` #### func (*GlDisableClientState) TypeID @@ -6759,6 +11569,7 @@ func (c *GlDisableClientState) TypeID() atom.TypeID ```go type GlDisableVertexAttribArray struct { binary.Generate + Location AttributeLocation } ``` @@ -6770,9 +11581,7 @@ GlDisableVertexAttribArray #### func NewGlDisableVertexAttribArray ```go -func NewGlDisableVertexAttribArray( - pLocation AttributeLocation, -) *GlDisableVertexAttribArray +func NewGlDisableVertexAttribArray(Location AttributeLocation) *GlDisableVertexAttribArray ``` #### func (*GlDisableVertexAttribArray) API @@ -6781,6 +11590,24 @@ func NewGlDisableVertexAttribArray( func (c *GlDisableVertexAttribArray) API() gfxapi.API ``` +#### func (*GlDisableVertexAttribArray) AddRead + +```go +func (a *GlDisableVertexAttribArray) AddRead(rng memory.Range, id binary.ID) *GlDisableVertexAttribArray +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDisableVertexAttribArray pointer is returned so that calls can be +chained. + +#### func (*GlDisableVertexAttribArray) AddWrite + +```go +func (a *GlDisableVertexAttribArray) AddWrite(rng memory.Range, id binary.ID) *GlDisableVertexAttribArray +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDisableVertexAttribArray pointer is returned so that calls can be +chained. + #### func (*GlDisableVertexAttribArray) Class ```go @@ -6796,19 +11623,25 @@ func (c *GlDisableVertexAttribArray) Flags() atom.Flags #### func (*GlDisableVertexAttribArray) Mutate ```go -func (ϟa *GlDisableVertexAttribArray) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDisableVertexAttribArray) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDisableVertexAttribArray) Observations + +```go +func (a *GlDisableVertexAttribArray) Observations() *atom.Observations ``` #### func (*GlDisableVertexAttribArray) Replay ```go -func (ϟa *GlDisableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDisableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDisableVertexAttribArray) String ```go -func (c *GlDisableVertexAttribArray) String() string +func (a *GlDisableVertexAttribArray) String() string ``` #### func (*GlDisableVertexAttribArray) TypeID @@ -6822,9 +11655,10 @@ func (c *GlDisableVertexAttribArray) TypeID() atom.TypeID ```go type GlDiscardFramebufferEXT struct { binary.Generate + Target FramebufferTarget NumAttachments int32 - Attachments DiscardFramebufferAttachmentArray + Attachments DiscardFramebufferAttachmentᵖ } ``` @@ -6835,11 +11669,7 @@ GlDiscardFramebufferEXT #### func NewGlDiscardFramebufferEXT ```go -func NewGlDiscardFramebufferEXT( - pTarget FramebufferTarget, - pNumAttachments int32, - pAttachments DiscardFramebufferAttachmentArray, -) *GlDiscardFramebufferEXT +func NewGlDiscardFramebufferEXT(Target FramebufferTarget, NumAttachments int32, Attachments memory.Pointer) *GlDiscardFramebufferEXT ``` #### func (*GlDiscardFramebufferEXT) API @@ -6848,6 +11678,24 @@ func NewGlDiscardFramebufferEXT( func (c *GlDiscardFramebufferEXT) API() gfxapi.API ``` +#### func (*GlDiscardFramebufferEXT) AddRead + +```go +func (a *GlDiscardFramebufferEXT) AddRead(rng memory.Range, id binary.ID) *GlDiscardFramebufferEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDiscardFramebufferEXT pointer is returned so that calls can be +chained. + +#### func (*GlDiscardFramebufferEXT) AddWrite + +```go +func (a *GlDiscardFramebufferEXT) AddWrite(rng memory.Range, id binary.ID) *GlDiscardFramebufferEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDiscardFramebufferEXT pointer is returned so that calls can be +chained. + #### func (*GlDiscardFramebufferEXT) Class ```go @@ -6863,19 +11711,25 @@ func (c *GlDiscardFramebufferEXT) Flags() atom.Flags #### func (*GlDiscardFramebufferEXT) Mutate ```go -func (ϟa *GlDiscardFramebufferEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDiscardFramebufferEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDiscardFramebufferEXT) Observations + +```go +func (a *GlDiscardFramebufferEXT) Observations() *atom.Observations ``` #### func (*GlDiscardFramebufferEXT) Replay ```go -func (ϟa *GlDiscardFramebufferEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDiscardFramebufferEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDiscardFramebufferEXT) String ```go -func (c *GlDiscardFramebufferEXT) String() string +func (a *GlDiscardFramebufferEXT) String() string ``` #### func (*GlDiscardFramebufferEXT) TypeID @@ -6889,6 +11743,7 @@ func (c *GlDiscardFramebufferEXT) TypeID() atom.TypeID ```go type GlDrawArrays struct { binary.Generate + DrawMode DrawMode FirstIndex int32 IndexCount int32 @@ -6902,11 +11757,7 @@ GlDrawArrays #### func NewGlDrawArrays ```go -func NewGlDrawArrays( - pDrawMode DrawMode, - pFirstIndex int32, - pIndexCount int32, -) *GlDrawArrays +func NewGlDrawArrays(Draw_mode DrawMode, First_index int32, Index_count int32) *GlDrawArrays ``` #### func (*GlDrawArrays) API @@ -6915,6 +11766,22 @@ func NewGlDrawArrays( func (c *GlDrawArrays) API() gfxapi.API ``` +#### func (*GlDrawArrays) AddRead + +```go +func (a *GlDrawArrays) AddRead(rng memory.Range, id binary.ID) *GlDrawArrays +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDrawArrays pointer is returned so that calls can be chained. + +#### func (*GlDrawArrays) AddWrite + +```go +func (a *GlDrawArrays) AddWrite(rng memory.Range, id binary.ID) *GlDrawArrays +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDrawArrays pointer is returned so that calls can be chained. + #### func (*GlDrawArrays) Class ```go @@ -6930,19 +11797,25 @@ func (c *GlDrawArrays) Flags() atom.Flags #### func (*GlDrawArrays) Mutate ```go -func (ϟa *GlDrawArrays) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDrawArrays) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDrawArrays) Observations + +```go +func (a *GlDrawArrays) Observations() *atom.Observations ``` #### func (*GlDrawArrays) Replay ```go -func (ϟa *GlDrawArrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDrawArrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDrawArrays) String ```go -func (c *GlDrawArrays) String() string +func (a *GlDrawArrays) String() string ``` #### func (*GlDrawArrays) TypeID @@ -6956,6 +11829,7 @@ func (c *GlDrawArrays) TypeID() atom.TypeID ```go type GlDrawElements struct { binary.Generate + DrawMode DrawMode ElementCount int32 IndicesType IndicesType @@ -6970,12 +11844,7 @@ GlDrawElements #### func NewGlDrawElements ```go -func NewGlDrawElements( - pDrawMode DrawMode, - pElementCount int32, - pIndicesType IndicesType, - pIndices IndicesPointer, -) *GlDrawElements +func NewGlDrawElements(Draw_mode DrawMode, Element_count int32, Indices_type IndicesType, Indices memory.Pointer) *GlDrawElements ``` #### func (*GlDrawElements) API @@ -6984,6 +11853,22 @@ func NewGlDrawElements( func (c *GlDrawElements) API() gfxapi.API ``` +#### func (*GlDrawElements) AddRead + +```go +func (a *GlDrawElements) AddRead(rng memory.Range, id binary.ID) *GlDrawElements +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlDrawElements pointer is returned so that calls can be chained. + +#### func (*GlDrawElements) AddWrite + +```go +func (a *GlDrawElements) AddWrite(rng memory.Range, id binary.ID) *GlDrawElements +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlDrawElements pointer is returned so that calls can be chained. + #### func (*GlDrawElements) Class ```go @@ -6999,19 +11884,25 @@ func (c *GlDrawElements) Flags() atom.Flags #### func (*GlDrawElements) Mutate ```go -func (ϟa *GlDrawElements) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlDrawElements) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlDrawElements) Observations + +```go +func (a *GlDrawElements) Observations() *atom.Observations ``` #### func (*GlDrawElements) Replay ```go -func (ϟa *GlDrawElements) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlDrawElements) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlDrawElements) String ```go -func (c *GlDrawElements) String() string +func (a *GlDrawElements) String() string ``` #### func (*GlDrawElements) TypeID @@ -7025,6 +11916,7 @@ func (c *GlDrawElements) TypeID() atom.TypeID ```go type GlEGLImageTargetRenderbufferStorageOES struct { binary.Generate + Target ImageTargetRenderbufferStorage Image TexturePointer } @@ -7037,10 +11929,7 @@ GlEGLImageTargetRenderbufferStorageOES #### func NewGlEGLImageTargetRenderbufferStorageOES ```go -func NewGlEGLImageTargetRenderbufferStorageOES( - pTarget ImageTargetRenderbufferStorage, - pImage TexturePointer, -) *GlEGLImageTargetRenderbufferStorageOES +func NewGlEGLImageTargetRenderbufferStorageOES(Target ImageTargetRenderbufferStorage, Image memory.Pointer) *GlEGLImageTargetRenderbufferStorageOES ``` #### func (*GlEGLImageTargetRenderbufferStorageOES) API @@ -7049,6 +11938,24 @@ func NewGlEGLImageTargetRenderbufferStorageOES( func (c *GlEGLImageTargetRenderbufferStorageOES) API() gfxapi.API ``` +#### func (*GlEGLImageTargetRenderbufferStorageOES) AddRead + +```go +func (a *GlEGLImageTargetRenderbufferStorageOES) AddRead(rng memory.Range, id binary.ID) *GlEGLImageTargetRenderbufferStorageOES +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEGLImageTargetRenderbufferStorageOES pointer is returned so that +calls can be chained. + +#### func (*GlEGLImageTargetRenderbufferStorageOES) AddWrite + +```go +func (a *GlEGLImageTargetRenderbufferStorageOES) AddWrite(rng memory.Range, id binary.ID) *GlEGLImageTargetRenderbufferStorageOES +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEGLImageTargetRenderbufferStorageOES pointer is returned so that +calls can be chained. + #### func (*GlEGLImageTargetRenderbufferStorageOES) Class ```go @@ -7064,19 +11971,25 @@ func (c *GlEGLImageTargetRenderbufferStorageOES) Flags() atom.Flags #### func (*GlEGLImageTargetRenderbufferStorageOES) Mutate ```go -func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEGLImageTargetRenderbufferStorageOES) Observations + +```go +func (a *GlEGLImageTargetRenderbufferStorageOES) Observations() *atom.Observations ``` #### func (*GlEGLImageTargetRenderbufferStorageOES) Replay ```go -func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEGLImageTargetRenderbufferStorageOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEGLImageTargetRenderbufferStorageOES) String ```go -func (c *GlEGLImageTargetRenderbufferStorageOES) String() string +func (a *GlEGLImageTargetRenderbufferStorageOES) String() string ``` #### func (*GlEGLImageTargetRenderbufferStorageOES) TypeID @@ -7090,6 +12003,7 @@ func (c *GlEGLImageTargetRenderbufferStorageOES) TypeID() atom.TypeID ```go type GlEGLImageTargetTexture2DOES struct { binary.Generate + Target ImageTargetTexture Image ImageOES } @@ -7102,10 +12016,7 @@ GlEGLImageTargetTexture2DOES #### func NewGlEGLImageTargetTexture2DOES ```go -func NewGlEGLImageTargetTexture2DOES( - pTarget ImageTargetTexture, - pImage ImageOES, -) *GlEGLImageTargetTexture2DOES +func NewGlEGLImageTargetTexture2DOES(Target ImageTargetTexture, Image memory.Pointer) *GlEGLImageTargetTexture2DOES ``` #### func (*GlEGLImageTargetTexture2DOES) API @@ -7114,6 +12025,24 @@ func NewGlEGLImageTargetTexture2DOES( func (c *GlEGLImageTargetTexture2DOES) API() gfxapi.API ``` +#### func (*GlEGLImageTargetTexture2DOES) AddRead + +```go +func (a *GlEGLImageTargetTexture2DOES) AddRead(rng memory.Range, id binary.ID) *GlEGLImageTargetTexture2DOES +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEGLImageTargetTexture2DOES pointer is returned so that calls can +be chained. + +#### func (*GlEGLImageTargetTexture2DOES) AddWrite + +```go +func (a *GlEGLImageTargetTexture2DOES) AddWrite(rng memory.Range, id binary.ID) *GlEGLImageTargetTexture2DOES +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEGLImageTargetTexture2DOES pointer is returned so that calls can +be chained. + #### func (*GlEGLImageTargetTexture2DOES) Class ```go @@ -7129,19 +12058,25 @@ func (c *GlEGLImageTargetTexture2DOES) Flags() atom.Flags #### func (*GlEGLImageTargetTexture2DOES) Mutate ```go -func (ϟa *GlEGLImageTargetTexture2DOES) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEGLImageTargetTexture2DOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEGLImageTargetTexture2DOES) Observations + +```go +func (a *GlEGLImageTargetTexture2DOES) Observations() *atom.Observations ``` #### func (*GlEGLImageTargetTexture2DOES) Replay ```go -func (ϟa *GlEGLImageTargetTexture2DOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEGLImageTargetTexture2DOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEGLImageTargetTexture2DOES) String ```go -func (c *GlEGLImageTargetTexture2DOES) String() string +func (a *GlEGLImageTargetTexture2DOES) String() string ``` #### func (*GlEGLImageTargetTexture2DOES) TypeID @@ -7155,6 +12090,7 @@ func (c *GlEGLImageTargetTexture2DOES) TypeID() atom.TypeID ```go type GlEnable struct { binary.Generate + Capability Capability } ``` @@ -7166,9 +12102,7 @@ GlEnable #### func NewGlEnable ```go -func NewGlEnable( - pCapability Capability, -) *GlEnable +func NewGlEnable(Capability Capability) *GlEnable ``` #### func (*GlEnable) API @@ -7177,6 +12111,22 @@ func NewGlEnable( func (c *GlEnable) API() gfxapi.API ``` +#### func (*GlEnable) AddRead + +```go +func (a *GlEnable) AddRead(rng memory.Range, id binary.ID) *GlEnable +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEnable pointer is returned so that calls can be chained. + +#### func (*GlEnable) AddWrite + +```go +func (a *GlEnable) AddWrite(rng memory.Range, id binary.ID) *GlEnable +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEnable pointer is returned so that calls can be chained. + #### func (*GlEnable) Class ```go @@ -7192,19 +12142,25 @@ func (c *GlEnable) Flags() atom.Flags #### func (*GlEnable) Mutate ```go -func (ϟa *GlEnable) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEnable) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEnable) Observations + +```go +func (a *GlEnable) Observations() *atom.Observations ``` #### func (*GlEnable) Replay ```go -func (ϟa *GlEnable) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEnable) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEnable) String ```go -func (c *GlEnable) String() string +func (a *GlEnable) String() string ``` #### func (*GlEnable) TypeID @@ -7218,6 +12174,7 @@ func (c *GlEnable) TypeID() atom.TypeID ```go type GlEnableClientState struct { binary.Generate + Type ArrayType } ``` @@ -7229,9 +12186,7 @@ GlEnableClientState #### func NewGlEnableClientState ```go -func NewGlEnableClientState( - pType ArrayType, -) *GlEnableClientState +func NewGlEnableClientState(Type ArrayType) *GlEnableClientState ``` #### func (*GlEnableClientState) API @@ -7240,6 +12195,24 @@ func NewGlEnableClientState( func (c *GlEnableClientState) API() gfxapi.API ``` +#### func (*GlEnableClientState) AddRead + +```go +func (a *GlEnableClientState) AddRead(rng memory.Range, id binary.ID) *GlEnableClientState +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEnableClientState pointer is returned so that calls can be +chained. + +#### func (*GlEnableClientState) AddWrite + +```go +func (a *GlEnableClientState) AddWrite(rng memory.Range, id binary.ID) *GlEnableClientState +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEnableClientState pointer is returned so that calls can be +chained. + #### func (*GlEnableClientState) Class ```go @@ -7255,19 +12228,25 @@ func (c *GlEnableClientState) Flags() atom.Flags #### func (*GlEnableClientState) Mutate ```go -func (ϟa *GlEnableClientState) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEnableClientState) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEnableClientState) Observations + +```go +func (a *GlEnableClientState) Observations() *atom.Observations ``` #### func (*GlEnableClientState) Replay ```go -func (ϟa *GlEnableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEnableClientState) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEnableClientState) String ```go -func (c *GlEnableClientState) String() string +func (a *GlEnableClientState) String() string ``` #### func (*GlEnableClientState) TypeID @@ -7281,6 +12260,7 @@ func (c *GlEnableClientState) TypeID() atom.TypeID ```go type GlEnableVertexAttribArray struct { binary.Generate + Location AttributeLocation } ``` @@ -7292,9 +12272,7 @@ GlEnableVertexAttribArray #### func NewGlEnableVertexAttribArray ```go -func NewGlEnableVertexAttribArray( - pLocation AttributeLocation, -) *GlEnableVertexAttribArray +func NewGlEnableVertexAttribArray(Location AttributeLocation) *GlEnableVertexAttribArray ``` #### func (*GlEnableVertexAttribArray) API @@ -7303,6 +12281,24 @@ func NewGlEnableVertexAttribArray( func (c *GlEnableVertexAttribArray) API() gfxapi.API ``` +#### func (*GlEnableVertexAttribArray) AddRead + +```go +func (a *GlEnableVertexAttribArray) AddRead(rng memory.Range, id binary.ID) *GlEnableVertexAttribArray +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEnableVertexAttribArray pointer is returned so that calls can be +chained. + +#### func (*GlEnableVertexAttribArray) AddWrite + +```go +func (a *GlEnableVertexAttribArray) AddWrite(rng memory.Range, id binary.ID) *GlEnableVertexAttribArray +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEnableVertexAttribArray pointer is returned so that calls can be +chained. + #### func (*GlEnableVertexAttribArray) Class ```go @@ -7318,19 +12314,25 @@ func (c *GlEnableVertexAttribArray) Flags() atom.Flags #### func (*GlEnableVertexAttribArray) Mutate ```go -func (ϟa *GlEnableVertexAttribArray) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEnableVertexAttribArray) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEnableVertexAttribArray) Observations + +```go +func (a *GlEnableVertexAttribArray) Observations() *atom.Observations ``` #### func (*GlEnableVertexAttribArray) Replay ```go -func (ϟa *GlEnableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEnableVertexAttribArray) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEnableVertexAttribArray) String ```go -func (c *GlEnableVertexAttribArray) String() string +func (a *GlEnableVertexAttribArray) String() string ``` #### func (*GlEnableVertexAttribArray) TypeID @@ -7344,6 +12346,7 @@ func (c *GlEnableVertexAttribArray) TypeID() atom.TypeID ```go type GlEndQuery struct { binary.Generate + Target QueryTarget } ``` @@ -7355,9 +12358,7 @@ GlEndQuery #### func NewGlEndQuery ```go -func NewGlEndQuery( - pTarget QueryTarget, -) *GlEndQuery +func NewGlEndQuery(Target QueryTarget) *GlEndQuery ``` #### func (*GlEndQuery) API @@ -7366,6 +12367,22 @@ func NewGlEndQuery( func (c *GlEndQuery) API() gfxapi.API ``` +#### func (*GlEndQuery) AddRead + +```go +func (a *GlEndQuery) AddRead(rng memory.Range, id binary.ID) *GlEndQuery +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEndQuery pointer is returned so that calls can be chained. + +#### func (*GlEndQuery) AddWrite + +```go +func (a *GlEndQuery) AddWrite(rng memory.Range, id binary.ID) *GlEndQuery +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEndQuery pointer is returned so that calls can be chained. + #### func (*GlEndQuery) Class ```go @@ -7381,19 +12398,25 @@ func (c *GlEndQuery) Flags() atom.Flags #### func (*GlEndQuery) Mutate ```go -func (ϟa *GlEndQuery) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEndQuery) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEndQuery) Observations + +```go +func (a *GlEndQuery) Observations() *atom.Observations ``` #### func (*GlEndQuery) Replay ```go -func (ϟa *GlEndQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEndQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEndQuery) String ```go -func (c *GlEndQuery) String() string +func (a *GlEndQuery) String() string ``` #### func (*GlEndQuery) TypeID @@ -7407,6 +12430,7 @@ func (c *GlEndQuery) TypeID() atom.TypeID ```go type GlEndQueryEXT struct { binary.Generate + Target QueryTarget } ``` @@ -7418,9 +12442,7 @@ GlEndQueryEXT #### func NewGlEndQueryEXT ```go -func NewGlEndQueryEXT( - pTarget QueryTarget, -) *GlEndQueryEXT +func NewGlEndQueryEXT(Target QueryTarget) *GlEndQueryEXT ``` #### func (*GlEndQueryEXT) API @@ -7429,6 +12451,22 @@ func NewGlEndQueryEXT( func (c *GlEndQueryEXT) API() gfxapi.API ``` +#### func (*GlEndQueryEXT) AddRead + +```go +func (a *GlEndQueryEXT) AddRead(rng memory.Range, id binary.ID) *GlEndQueryEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEndQueryEXT pointer is returned so that calls can be chained. + +#### func (*GlEndQueryEXT) AddWrite + +```go +func (a *GlEndQueryEXT) AddWrite(rng memory.Range, id binary.ID) *GlEndQueryEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEndQueryEXT pointer is returned so that calls can be chained. + #### func (*GlEndQueryEXT) Class ```go @@ -7444,19 +12482,25 @@ func (c *GlEndQueryEXT) Flags() atom.Flags #### func (*GlEndQueryEXT) Mutate ```go -func (ϟa *GlEndQueryEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEndQueryEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEndQueryEXT) Observations + +```go +func (a *GlEndQueryEXT) Observations() *atom.Observations ``` #### func (*GlEndQueryEXT) Replay ```go -func (ϟa *GlEndQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEndQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEndQueryEXT) String ```go -func (c *GlEndQueryEXT) String() string +func (a *GlEndQueryEXT) String() string ``` #### func (*GlEndQueryEXT) TypeID @@ -7470,6 +12514,7 @@ func (c *GlEndQueryEXT) TypeID() atom.TypeID ```go type GlEndTilingQCOM struct { binary.Generate + PreserveMask TilePreserveMaskQCOM } ``` @@ -7481,9 +12526,7 @@ GlEndTilingQCOM #### func NewGlEndTilingQCOM ```go -func NewGlEndTilingQCOM( - pPreserveMask TilePreserveMaskQCOM, -) *GlEndTilingQCOM +func NewGlEndTilingQCOM(Preserve_mask TilePreserveMaskQCOM) *GlEndTilingQCOM ``` #### func (*GlEndTilingQCOM) API @@ -7492,6 +12535,22 @@ func NewGlEndTilingQCOM( func (c *GlEndTilingQCOM) API() gfxapi.API ``` +#### func (*GlEndTilingQCOM) AddRead + +```go +func (a *GlEndTilingQCOM) AddRead(rng memory.Range, id binary.ID) *GlEndTilingQCOM +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlEndTilingQCOM pointer is returned so that calls can be chained. + +#### func (*GlEndTilingQCOM) AddWrite + +```go +func (a *GlEndTilingQCOM) AddWrite(rng memory.Range, id binary.ID) *GlEndTilingQCOM +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlEndTilingQCOM pointer is returned so that calls can be chained. + #### func (*GlEndTilingQCOM) Class ```go @@ -7507,19 +12566,25 @@ func (c *GlEndTilingQCOM) Flags() atom.Flags #### func (*GlEndTilingQCOM) Mutate ```go -func (ϟa *GlEndTilingQCOM) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlEndTilingQCOM) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlEndTilingQCOM) Observations + +```go +func (a *GlEndTilingQCOM) Observations() *atom.Observations ``` #### func (*GlEndTilingQCOM) Replay ```go -func (ϟa *GlEndTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlEndTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlEndTilingQCOM) String ```go -func (c *GlEndTilingQCOM) String() string +func (a *GlEndTilingQCOM) String() string ``` #### func (*GlEndTilingQCOM) TypeID @@ -7528,6 +12593,92 @@ func (c *GlEndTilingQCOM) String() string func (c *GlEndTilingQCOM) TypeID() atom.TypeID ``` +#### type GlFenceSync + +```go +type GlFenceSync struct { + binary.Generate + + Condition SyncCondition + SyncFlags SyncFlags + Result SyncObject +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlFenceSync +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlFenceSync + +```go +func NewGlFenceSync(Condition SyncCondition, SyncFlags SyncFlags, Result SyncObject) *GlFenceSync +``` + +#### func (*GlFenceSync) API + +```go +func (c *GlFenceSync) API() gfxapi.API +``` + +#### func (*GlFenceSync) AddRead + +```go +func (a *GlFenceSync) AddRead(rng memory.Range, id binary.ID) *GlFenceSync +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFenceSync pointer is returned so that calls can be chained. + +#### func (*GlFenceSync) AddWrite + +```go +func (a *GlFenceSync) AddWrite(rng memory.Range, id binary.ID) *GlFenceSync +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFenceSync pointer is returned so that calls can be chained. + +#### func (*GlFenceSync) Class + +```go +func (*GlFenceSync) Class() binary.Class +``` + +#### func (*GlFenceSync) Flags + +```go +func (c *GlFenceSync) Flags() atom.Flags +``` + +#### func (*GlFenceSync) Mutate + +```go +func (ϟa *GlFenceSync) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFenceSync) Observations + +```go +func (a *GlFenceSync) Observations() *atom.Observations +``` + +#### func (*GlFenceSync) Replay + +```go +func (ϟa *GlFenceSync) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlFenceSync) String + +```go +func (a *GlFenceSync) String() string +``` + +#### func (*GlFenceSync) TypeID + +```go +func (c *GlFenceSync) TypeID() atom.TypeID +``` + #### type GlFinish ```go @@ -7552,6 +12703,22 @@ func NewGlFinish() *GlFinish func (c *GlFinish) API() gfxapi.API ``` +#### func (*GlFinish) AddRead + +```go +func (a *GlFinish) AddRead(rng memory.Range, id binary.ID) *GlFinish +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFinish pointer is returned so that calls can be chained. + +#### func (*GlFinish) AddWrite + +```go +func (a *GlFinish) AddWrite(rng memory.Range, id binary.ID) *GlFinish +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFinish pointer is returned so that calls can be chained. + #### func (*GlFinish) Class ```go @@ -7567,19 +12734,25 @@ func (c *GlFinish) Flags() atom.Flags #### func (*GlFinish) Mutate ```go -func (ϟa *GlFinish) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlFinish) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFinish) Observations + +```go +func (a *GlFinish) Observations() *atom.Observations ``` #### func (*GlFinish) Replay ```go -func (ϟa *GlFinish) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlFinish) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlFinish) String ```go -func (c *GlFinish) String() string +func (a *GlFinish) String() string ``` #### func (*GlFinish) TypeID @@ -7612,6 +12785,22 @@ func NewGlFlush() *GlFlush func (c *GlFlush) API() gfxapi.API ``` +#### func (*GlFlush) AddRead + +```go +func (a *GlFlush) AddRead(rng memory.Range, id binary.ID) *GlFlush +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFlush pointer is returned so that calls can be chained. + +#### func (*GlFlush) AddWrite + +```go +func (a *GlFlush) AddWrite(rng memory.Range, id binary.ID) *GlFlush +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFlush pointer is returned so that calls can be chained. + #### func (*GlFlush) Class ```go @@ -7627,19 +12816,25 @@ func (c *GlFlush) Flags() atom.Flags #### func (*GlFlush) Mutate ```go -func (ϟa *GlFlush) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlFlush) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFlush) Observations + +```go +func (a *GlFlush) Observations() *atom.Observations ``` #### func (*GlFlush) Replay ```go -func (ϟa *GlFlush) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlFlush) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlFlush) String ```go -func (c *GlFlush) String() string +func (a *GlFlush) String() string ``` #### func (*GlFlush) TypeID @@ -7653,6 +12848,7 @@ func (c *GlFlush) TypeID() atom.TypeID ```go type GlFramebufferRenderbuffer struct { binary.Generate + FramebufferTarget FramebufferTarget FramebufferAttachment FramebufferAttachment RenderbufferTarget RenderbufferTarget @@ -7667,12 +12863,7 @@ GlFramebufferRenderbuffer #### func NewGlFramebufferRenderbuffer ```go -func NewGlFramebufferRenderbuffer( - pFramebufferTarget FramebufferTarget, - pFramebufferAttachment FramebufferAttachment, - pRenderbufferTarget RenderbufferTarget, - pRenderbuffer RenderbufferId, -) *GlFramebufferRenderbuffer +func NewGlFramebufferRenderbuffer(Framebuffer_target FramebufferTarget, Framebuffer_attachment FramebufferAttachment, Renderbuffer_target RenderbufferTarget, Renderbuffer RenderbufferId) *GlFramebufferRenderbuffer ``` #### func (*GlFramebufferRenderbuffer) API @@ -7681,6 +12872,24 @@ func NewGlFramebufferRenderbuffer( func (c *GlFramebufferRenderbuffer) API() gfxapi.API ``` +#### func (*GlFramebufferRenderbuffer) AddRead + +```go +func (a *GlFramebufferRenderbuffer) AddRead(rng memory.Range, id binary.ID) *GlFramebufferRenderbuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFramebufferRenderbuffer pointer is returned so that calls can be +chained. + +#### func (*GlFramebufferRenderbuffer) AddWrite + +```go +func (a *GlFramebufferRenderbuffer) AddWrite(rng memory.Range, id binary.ID) *GlFramebufferRenderbuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFramebufferRenderbuffer pointer is returned so that calls can be +chained. + #### func (*GlFramebufferRenderbuffer) Class ```go @@ -7696,19 +12905,25 @@ func (c *GlFramebufferRenderbuffer) Flags() atom.Flags #### func (*GlFramebufferRenderbuffer) Mutate ```go -func (ϟa *GlFramebufferRenderbuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlFramebufferRenderbuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFramebufferRenderbuffer) Observations + +```go +func (a *GlFramebufferRenderbuffer) Observations() *atom.Observations ``` #### func (*GlFramebufferRenderbuffer) Replay ```go -func (ϟa *GlFramebufferRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlFramebufferRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlFramebufferRenderbuffer) String ```go -func (c *GlFramebufferRenderbuffer) String() string +func (a *GlFramebufferRenderbuffer) String() string ``` #### func (*GlFramebufferRenderbuffer) TypeID @@ -7722,6 +12937,7 @@ func (c *GlFramebufferRenderbuffer) TypeID() atom.TypeID ```go type GlFramebufferTexture2D struct { binary.Generate + FramebufferTarget FramebufferTarget FramebufferAttachment FramebufferAttachment TextureTarget TextureImageTarget @@ -7737,13 +12953,7 @@ GlFramebufferTexture2D #### func NewGlFramebufferTexture2D ```go -func NewGlFramebufferTexture2D( - pFramebufferTarget FramebufferTarget, - pFramebufferAttachment FramebufferAttachment, - pTextureTarget TextureImageTarget, - pTexture TextureId, - pLevel int32, -) *GlFramebufferTexture2D +func NewGlFramebufferTexture2D(Framebuffer_target FramebufferTarget, Framebuffer_attachment FramebufferAttachment, Texture_target TextureImageTarget, Texture TextureId, Level int32) *GlFramebufferTexture2D ``` #### func (*GlFramebufferTexture2D) API @@ -7752,6 +12962,24 @@ func NewGlFramebufferTexture2D( func (c *GlFramebufferTexture2D) API() gfxapi.API ``` +#### func (*GlFramebufferTexture2D) AddRead + +```go +func (a *GlFramebufferTexture2D) AddRead(rng memory.Range, id binary.ID) *GlFramebufferTexture2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFramebufferTexture2D pointer is returned so that calls can be +chained. + +#### func (*GlFramebufferTexture2D) AddWrite + +```go +func (a *GlFramebufferTexture2D) AddWrite(rng memory.Range, id binary.ID) *GlFramebufferTexture2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFramebufferTexture2D pointer is returned so that calls can be +chained. + #### func (*GlFramebufferTexture2D) Class ```go @@ -7767,19 +12995,25 @@ func (c *GlFramebufferTexture2D) Flags() atom.Flags #### func (*GlFramebufferTexture2D) Mutate ```go -func (ϟa *GlFramebufferTexture2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlFramebufferTexture2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFramebufferTexture2D) Observations + +```go +func (a *GlFramebufferTexture2D) Observations() *atom.Observations ``` #### func (*GlFramebufferTexture2D) Replay ```go -func (ϟa *GlFramebufferTexture2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlFramebufferTexture2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlFramebufferTexture2D) String ```go -func (c *GlFramebufferTexture2D) String() string +func (a *GlFramebufferTexture2D) String() string ``` #### func (*GlFramebufferTexture2D) TypeID @@ -7793,6 +13027,7 @@ func (c *GlFramebufferTexture2D) TypeID() atom.TypeID ```go type GlFrontFace struct { binary.Generate + Orientation FaceOrientation } ``` @@ -7804,9 +13039,7 @@ GlFrontFace #### func NewGlFrontFace ```go -func NewGlFrontFace( - pOrientation FaceOrientation, -) *GlFrontFace +func NewGlFrontFace(Orientation FaceOrientation) *GlFrontFace ``` #### func (*GlFrontFace) API @@ -7815,6 +13048,22 @@ func NewGlFrontFace( func (c *GlFrontFace) API() gfxapi.API ``` +#### func (*GlFrontFace) AddRead + +```go +func (a *GlFrontFace) AddRead(rng memory.Range, id binary.ID) *GlFrontFace +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlFrontFace pointer is returned so that calls can be chained. + +#### func (*GlFrontFace) AddWrite + +```go +func (a *GlFrontFace) AddWrite(rng memory.Range, id binary.ID) *GlFrontFace +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlFrontFace pointer is returned so that calls can be chained. + #### func (*GlFrontFace) Class ```go @@ -7830,19 +13079,25 @@ func (c *GlFrontFace) Flags() atom.Flags #### func (*GlFrontFace) Mutate ```go -func (ϟa *GlFrontFace) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlFrontFace) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlFrontFace) Observations + +```go +func (a *GlFrontFace) Observations() *atom.Observations ``` #### func (*GlFrontFace) Replay ```go -func (ϟa *GlFrontFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlFrontFace) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlFrontFace) String ```go -func (c *GlFrontFace) String() string +func (a *GlFrontFace) String() string ``` #### func (*GlFrontFace) TypeID @@ -7856,8 +13111,9 @@ func (c *GlFrontFace) TypeID() atom.TypeID ```go type GlGenBuffers struct { binary.Generate + Count int32 - Buffers BufferIdArray + Buffers BufferIdᵖ } ``` @@ -7868,10 +13124,7 @@ GlGenBuffers #### func NewGlGenBuffers ```go -func NewGlGenBuffers( - pCount int32, - pBuffers BufferIdArray, -) *GlGenBuffers +func NewGlGenBuffers(Count int32, Buffers memory.Pointer) *GlGenBuffers ``` #### func (*GlGenBuffers) API @@ -7880,55 +13133,62 @@ func NewGlGenBuffers( func (c *GlGenBuffers) API() gfxapi.API ``` -#### func (*GlGenBuffers) Class +#### func (*GlGenBuffers) AddRead ```go -func (*GlGenBuffers) Class() binary.Class +func (a *GlGenBuffers) AddRead(rng memory.Range, id binary.ID) *GlGenBuffers ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenBuffers pointer is returned so that calls can be chained. -#### func (*GlGenBuffers) Flags +#### func (*GlGenBuffers) AddWrite ```go -func (c *GlGenBuffers) Flags() atom.Flags +func (a *GlGenBuffers) AddWrite(rng memory.Range, id binary.ID) *GlGenBuffers ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenBuffers pointer is returned so that calls can be chained. -#### func (*GlGenBuffers) Mutate +#### func (*GlGenBuffers) Class ```go -func (ϟa *GlGenBuffers) Mutate(ϟs *gfxapi.State) error +func (*GlGenBuffers) Class() binary.Class ``` -#### func (*GlGenBuffers) Replay +#### func (*GlGenBuffers) Flags ```go -func (ϟa *GlGenBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGenBuffers) Flags() atom.Flags ``` -#### func (*GlGenBuffers) String +#### func (*GlGenBuffers) Mutate ```go -func (c *GlGenBuffers) String() string +func (ϟa *GlGenBuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGenBuffers) TypeID +#### func (*GlGenBuffers) Observations ```go -func (c *GlGenBuffers) TypeID() atom.TypeID +func (a *GlGenBuffers) Observations() *atom.Observations ``` -#### type GlGenBuffers_Postback +#### func (*GlGenBuffers) Replay ```go -type GlGenBuffers_Postback struct { - Buffers BufferIdArray -} +func (ϟa *GlGenBuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGenBuffers) String + +```go +func (a *GlGenBuffers) String() string +``` -#### func (*GlGenBuffers_Postback) Decode +#### func (*GlGenBuffers) TypeID ```go -func (o *GlGenBuffers_Postback) Decode(buffers_cnt uint64, d binary.Decoder) error +func (c *GlGenBuffers) TypeID() atom.TypeID ``` #### type GlGenFramebuffers @@ -7936,8 +13196,9 @@ func (o *GlGenBuffers_Postback) Decode(buffers_cnt uint64, d binary.Decoder) err ```go type GlGenFramebuffers struct { binary.Generate + Count int32 - Framebuffers FramebufferIdArray + Framebuffers FramebufferIdᵖ } ``` @@ -7948,10 +13209,7 @@ GlGenFramebuffers #### func NewGlGenFramebuffers ```go -func NewGlGenFramebuffers( - pCount int32, - pFramebuffers FramebufferIdArray, -) *GlGenFramebuffers +func NewGlGenFramebuffers(Count int32, Framebuffers memory.Pointer) *GlGenFramebuffers ``` #### func (*GlGenFramebuffers) API @@ -7960,55 +13218,62 @@ func NewGlGenFramebuffers( func (c *GlGenFramebuffers) API() gfxapi.API ``` -#### func (*GlGenFramebuffers) Class +#### func (*GlGenFramebuffers) AddRead ```go -func (*GlGenFramebuffers) Class() binary.Class +func (a *GlGenFramebuffers) AddRead(rng memory.Range, id binary.ID) *GlGenFramebuffers ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenFramebuffers pointer is returned so that calls can be chained. -#### func (*GlGenFramebuffers) Flags +#### func (*GlGenFramebuffers) AddWrite ```go -func (c *GlGenFramebuffers) Flags() atom.Flags +func (a *GlGenFramebuffers) AddWrite(rng memory.Range, id binary.ID) *GlGenFramebuffers ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenFramebuffers pointer is returned so that calls can be chained. -#### func (*GlGenFramebuffers) Mutate +#### func (*GlGenFramebuffers) Class ```go -func (ϟa *GlGenFramebuffers) Mutate(ϟs *gfxapi.State) error +func (*GlGenFramebuffers) Class() binary.Class ``` -#### func (*GlGenFramebuffers) Replay +#### func (*GlGenFramebuffers) Flags ```go -func (ϟa *GlGenFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGenFramebuffers) Flags() atom.Flags ``` -#### func (*GlGenFramebuffers) String +#### func (*GlGenFramebuffers) Mutate ```go -func (c *GlGenFramebuffers) String() string +func (ϟa *GlGenFramebuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGenFramebuffers) TypeID +#### func (*GlGenFramebuffers) Observations ```go -func (c *GlGenFramebuffers) TypeID() atom.TypeID +func (a *GlGenFramebuffers) Observations() *atom.Observations ``` -#### type GlGenFramebuffers_Postback +#### func (*GlGenFramebuffers) Replay ```go -type GlGenFramebuffers_Postback struct { - Framebuffers FramebufferIdArray -} +func (ϟa *GlGenFramebuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGenFramebuffers) String -#### func (*GlGenFramebuffers_Postback) Decode +```go +func (a *GlGenFramebuffers) String() string +``` + +#### func (*GlGenFramebuffers) TypeID ```go -func (o *GlGenFramebuffers_Postback) Decode(framebuffers_cnt uint64, d binary.Decoder) error +func (c *GlGenFramebuffers) TypeID() atom.TypeID ``` #### type GlGenQueries @@ -8016,8 +13281,9 @@ func (o *GlGenFramebuffers_Postback) Decode(framebuffers_cnt uint64, d binary.De ```go type GlGenQueries struct { binary.Generate + Count int32 - Queries QueryIdArray + Queries QueryIdᵖ } ``` @@ -8028,10 +13294,7 @@ GlGenQueries #### func NewGlGenQueries ```go -func NewGlGenQueries( - pCount int32, - pQueries QueryIdArray, -) *GlGenQueries +func NewGlGenQueries(Count int32, Queries memory.Pointer) *GlGenQueries ``` #### func (*GlGenQueries) API @@ -8040,6 +13303,22 @@ func NewGlGenQueries( func (c *GlGenQueries) API() gfxapi.API ``` +#### func (*GlGenQueries) AddRead + +```go +func (a *GlGenQueries) AddRead(rng memory.Range, id binary.ID) *GlGenQueries +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenQueries pointer is returned so that calls can be chained. + +#### func (*GlGenQueries) AddWrite + +```go +func (a *GlGenQueries) AddWrite(rng memory.Range, id binary.ID) *GlGenQueries +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenQueries pointer is returned so that calls can be chained. + #### func (*GlGenQueries) Class ```go @@ -8055,19 +13334,25 @@ func (c *GlGenQueries) Flags() atom.Flags #### func (*GlGenQueries) Mutate ```go -func (ϟa *GlGenQueries) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGenQueries) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGenQueries) Observations + +```go +func (a *GlGenQueries) Observations() *atom.Observations ``` #### func (*GlGenQueries) Replay ```go -func (ϟa *GlGenQueries) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGenQueries) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGenQueries) String ```go -func (c *GlGenQueries) String() string +func (a *GlGenQueries) String() string ``` #### func (*GlGenQueries) TypeID @@ -8081,8 +13366,9 @@ func (c *GlGenQueries) TypeID() atom.TypeID ```go type GlGenQueriesEXT struct { binary.Generate + Count int32 - Queries QueryIdArray + Queries QueryIdᵖ } ``` @@ -8093,10 +13379,7 @@ GlGenQueriesEXT #### func NewGlGenQueriesEXT ```go -func NewGlGenQueriesEXT( - pCount int32, - pQueries QueryIdArray, -) *GlGenQueriesEXT +func NewGlGenQueriesEXT(Count int32, Queries memory.Pointer) *GlGenQueriesEXT ``` #### func (*GlGenQueriesEXT) API @@ -8105,70 +13388,62 @@ func NewGlGenQueriesEXT( func (c *GlGenQueriesEXT) API() gfxapi.API ``` -#### func (*GlGenQueriesEXT) Class +#### func (*GlGenQueriesEXT) AddRead ```go -func (*GlGenQueriesEXT) Class() binary.Class +func (a *GlGenQueriesEXT) AddRead(rng memory.Range, id binary.ID) *GlGenQueriesEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenQueriesEXT pointer is returned so that calls can be chained. -#### func (*GlGenQueriesEXT) Flags +#### func (*GlGenQueriesEXT) AddWrite ```go -func (c *GlGenQueriesEXT) Flags() atom.Flags -``` - -#### func (*GlGenQueriesEXT) Mutate - -```go -func (ϟa *GlGenQueriesEXT) Mutate(ϟs *gfxapi.State) error +func (a *GlGenQueriesEXT) AddWrite(rng memory.Range, id binary.ID) *GlGenQueriesEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenQueriesEXT pointer is returned so that calls can be chained. -#### func (*GlGenQueriesEXT) Replay +#### func (*GlGenQueriesEXT) Class ```go -func (ϟa *GlGenQueriesEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (*GlGenQueriesEXT) Class() binary.Class ``` -#### func (*GlGenQueriesEXT) String +#### func (*GlGenQueriesEXT) Flags ```go -func (c *GlGenQueriesEXT) String() string +func (c *GlGenQueriesEXT) Flags() atom.Flags ``` -#### func (*GlGenQueriesEXT) TypeID +#### func (*GlGenQueriesEXT) Mutate ```go -func (c *GlGenQueriesEXT) TypeID() atom.TypeID +func (ϟa *GlGenQueriesEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type GlGenQueriesEXT_Postback +#### func (*GlGenQueriesEXT) Observations ```go -type GlGenQueriesEXT_Postback struct { - Queries QueryIdArray -} +func (a *GlGenQueriesEXT) Observations() *atom.Observations ``` - -#### func (*GlGenQueriesEXT_Postback) Decode +#### func (*GlGenQueriesEXT) Replay ```go -func (o *GlGenQueriesEXT_Postback) Decode(queries_cnt uint64, d binary.Decoder) error +func (ϟa *GlGenQueriesEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` -#### type GlGenQueries_Postback +#### func (*GlGenQueriesEXT) String ```go -type GlGenQueries_Postback struct { - Queries QueryIdArray -} +func (a *GlGenQueriesEXT) String() string ``` - -#### func (*GlGenQueries_Postback) Decode +#### func (*GlGenQueriesEXT) TypeID ```go -func (o *GlGenQueries_Postback) Decode(queries_cnt uint64, d binary.Decoder) error +func (c *GlGenQueriesEXT) TypeID() atom.TypeID ``` #### type GlGenRenderbuffers @@ -8176,8 +13451,9 @@ func (o *GlGenQueries_Postback) Decode(queries_cnt uint64, d binary.Decoder) err ```go type GlGenRenderbuffers struct { binary.Generate + Count int32 - Renderbuffers RenderbufferIdArray + Renderbuffers RenderbufferIdᵖ } ``` @@ -8188,10 +13464,7 @@ GlGenRenderbuffers #### func NewGlGenRenderbuffers ```go -func NewGlGenRenderbuffers( - pCount int32, - pRenderbuffers RenderbufferIdArray, -) *GlGenRenderbuffers +func NewGlGenRenderbuffers(Count int32, Renderbuffers memory.Pointer) *GlGenRenderbuffers ``` #### func (*GlGenRenderbuffers) API @@ -8200,55 +13473,64 @@ func NewGlGenRenderbuffers( func (c *GlGenRenderbuffers) API() gfxapi.API ``` -#### func (*GlGenRenderbuffers) Class +#### func (*GlGenRenderbuffers) AddRead ```go -func (*GlGenRenderbuffers) Class() binary.Class +func (a *GlGenRenderbuffers) AddRead(rng memory.Range, id binary.ID) *GlGenRenderbuffers ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenRenderbuffers pointer is returned so that calls can be +chained. -#### func (*GlGenRenderbuffers) Flags +#### func (*GlGenRenderbuffers) AddWrite ```go -func (c *GlGenRenderbuffers) Flags() atom.Flags +func (a *GlGenRenderbuffers) AddWrite(rng memory.Range, id binary.ID) *GlGenRenderbuffers ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenRenderbuffers pointer is returned so that calls can be +chained. -#### func (*GlGenRenderbuffers) Mutate +#### func (*GlGenRenderbuffers) Class ```go -func (ϟa *GlGenRenderbuffers) Mutate(ϟs *gfxapi.State) error +func (*GlGenRenderbuffers) Class() binary.Class ``` -#### func (*GlGenRenderbuffers) Replay +#### func (*GlGenRenderbuffers) Flags ```go -func (ϟa *GlGenRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGenRenderbuffers) Flags() atom.Flags ``` -#### func (*GlGenRenderbuffers) String +#### func (*GlGenRenderbuffers) Mutate ```go -func (c *GlGenRenderbuffers) String() string +func (ϟa *GlGenRenderbuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGenRenderbuffers) TypeID +#### func (*GlGenRenderbuffers) Observations ```go -func (c *GlGenRenderbuffers) TypeID() atom.TypeID +func (a *GlGenRenderbuffers) Observations() *atom.Observations ``` -#### type GlGenRenderbuffers_Postback +#### func (*GlGenRenderbuffers) Replay ```go -type GlGenRenderbuffers_Postback struct { - Renderbuffers RenderbufferIdArray -} +func (ϟa *GlGenRenderbuffers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGenRenderbuffers) String + +```go +func (a *GlGenRenderbuffers) String() string +``` -#### func (*GlGenRenderbuffers_Postback) Decode +#### func (*GlGenRenderbuffers) TypeID ```go -func (o *GlGenRenderbuffers_Postback) Decode(renderbuffers_cnt uint64, d binary.Decoder) error +func (c *GlGenRenderbuffers) TypeID() atom.TypeID ``` #### type GlGenTextures @@ -8256,8 +13538,9 @@ func (o *GlGenRenderbuffers_Postback) Decode(renderbuffers_cnt uint64, d binary. ```go type GlGenTextures struct { binary.Generate + Count int32 - Textures TextureIdArray + Textures TextureIdᵖ } ``` @@ -8268,10 +13551,7 @@ GlGenTextures #### func NewGlGenTextures ```go -func NewGlGenTextures( - pCount int32, - pTextures TextureIdArray, -) *GlGenTextures +func NewGlGenTextures(Count int32, Textures memory.Pointer) *GlGenTextures ``` #### func (*GlGenTextures) API @@ -8280,6 +13560,22 @@ func NewGlGenTextures( func (c *GlGenTextures) API() gfxapi.API ``` +#### func (*GlGenTextures) AddRead + +```go +func (a *GlGenTextures) AddRead(rng memory.Range, id binary.ID) *GlGenTextures +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenTextures pointer is returned so that calls can be chained. + +#### func (*GlGenTextures) AddWrite + +```go +func (a *GlGenTextures) AddWrite(rng memory.Range, id binary.ID) *GlGenTextures +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenTextures pointer is returned so that calls can be chained. + #### func (*GlGenTextures) Class ```go @@ -8295,19 +13591,25 @@ func (c *GlGenTextures) Flags() atom.Flags #### func (*GlGenTextures) Mutate ```go -func (ϟa *GlGenTextures) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGenTextures) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGenTextures) Observations + +```go +func (a *GlGenTextures) Observations() *atom.Observations ``` #### func (*GlGenTextures) Replay ```go -func (ϟa *GlGenTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGenTextures) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGenTextures) String ```go -func (c *GlGenTextures) String() string +func (a *GlGenTextures) String() string ``` #### func (*GlGenTextures) TypeID @@ -8316,19 +13618,89 @@ func (c *GlGenTextures) String() string func (c *GlGenTextures) TypeID() atom.TypeID ``` -#### type GlGenTextures_Postback +#### type GlGenVertexArrays ```go -type GlGenTextures_Postback struct { - Textures TextureIdArray +type GlGenVertexArrays struct { + binary.Generate + + Count int32 + Arrays VertexArrayIdᵖ } ``` +////////////////////////////////////////////////////////////////////////////// +GlGenVertexArrays +////////////////////////////////////////////////////////////////////////////// -#### func (*GlGenTextures_Postback) Decode +#### func NewGlGenVertexArrays ```go -func (o *GlGenTextures_Postback) Decode(textures_cnt uint64, d binary.Decoder) error +func NewGlGenVertexArrays(Count int32, Arrays memory.Pointer) *GlGenVertexArrays +``` + +#### func (*GlGenVertexArrays) API + +```go +func (c *GlGenVertexArrays) API() gfxapi.API +``` + +#### func (*GlGenVertexArrays) AddRead + +```go +func (a *GlGenVertexArrays) AddRead(rng memory.Range, id binary.ID) *GlGenVertexArrays +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenVertexArrays pointer is returned so that calls can be chained. + +#### func (*GlGenVertexArrays) AddWrite + +```go +func (a *GlGenVertexArrays) AddWrite(rng memory.Range, id binary.ID) *GlGenVertexArrays +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenVertexArrays pointer is returned so that calls can be chained. + +#### func (*GlGenVertexArrays) Class + +```go +func (*GlGenVertexArrays) Class() binary.Class +``` + +#### func (*GlGenVertexArrays) Flags + +```go +func (c *GlGenVertexArrays) Flags() atom.Flags +``` + +#### func (*GlGenVertexArrays) Mutate + +```go +func (ϟa *GlGenVertexArrays) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGenVertexArrays) Observations + +```go +func (a *GlGenVertexArrays) Observations() *atom.Observations +``` + +#### func (*GlGenVertexArrays) Replay + +```go +func (ϟa *GlGenVertexArrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGenVertexArrays) String + +```go +func (a *GlGenVertexArrays) String() string +``` + +#### func (*GlGenVertexArrays) TypeID + +```go +func (c *GlGenVertexArrays) TypeID() atom.TypeID ``` #### type GlGenVertexArraysOES @@ -8336,8 +13708,9 @@ func (o *GlGenTextures_Postback) Decode(textures_cnt uint64, d binary.Decoder) e ```go type GlGenVertexArraysOES struct { binary.Generate + Count int32 - Arrays VertexArrayIdArray + Arrays VertexArrayIdᵖ } ``` @@ -8348,10 +13721,7 @@ GlGenVertexArraysOES #### func NewGlGenVertexArraysOES ```go -func NewGlGenVertexArraysOES( - pCount int32, - pArrays VertexArrayIdArray, -) *GlGenVertexArraysOES +func NewGlGenVertexArraysOES(Count int32, Arrays memory.Pointer) *GlGenVertexArraysOES ``` #### func (*GlGenVertexArraysOES) API @@ -8360,55 +13730,64 @@ func NewGlGenVertexArraysOES( func (c *GlGenVertexArraysOES) API() gfxapi.API ``` -#### func (*GlGenVertexArraysOES) Class +#### func (*GlGenVertexArraysOES) AddRead ```go -func (*GlGenVertexArraysOES) Class() binary.Class +func (a *GlGenVertexArraysOES) AddRead(rng memory.Range, id binary.ID) *GlGenVertexArraysOES ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenVertexArraysOES pointer is returned so that calls can be +chained. -#### func (*GlGenVertexArraysOES) Flags +#### func (*GlGenVertexArraysOES) AddWrite ```go -func (c *GlGenVertexArraysOES) Flags() atom.Flags +func (a *GlGenVertexArraysOES) AddWrite(rng memory.Range, id binary.ID) *GlGenVertexArraysOES ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenVertexArraysOES pointer is returned so that calls can be +chained. -#### func (*GlGenVertexArraysOES) Mutate +#### func (*GlGenVertexArraysOES) Class ```go -func (ϟa *GlGenVertexArraysOES) Mutate(ϟs *gfxapi.State) error +func (*GlGenVertexArraysOES) Class() binary.Class ``` -#### func (*GlGenVertexArraysOES) Replay +#### func (*GlGenVertexArraysOES) Flags ```go -func (ϟa *GlGenVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGenVertexArraysOES) Flags() atom.Flags ``` -#### func (*GlGenVertexArraysOES) String +#### func (*GlGenVertexArraysOES) Mutate ```go -func (c *GlGenVertexArraysOES) String() string +func (ϟa *GlGenVertexArraysOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGenVertexArraysOES) TypeID +#### func (*GlGenVertexArraysOES) Observations ```go -func (c *GlGenVertexArraysOES) TypeID() atom.TypeID +func (a *GlGenVertexArraysOES) Observations() *atom.Observations ``` -#### type GlGenVertexArraysOES_Postback +#### func (*GlGenVertexArraysOES) Replay ```go -type GlGenVertexArraysOES_Postback struct { - Arrays VertexArrayIdArray -} +func (ϟa *GlGenVertexArraysOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGenVertexArraysOES) String -#### func (*GlGenVertexArraysOES_Postback) Decode +```go +func (a *GlGenVertexArraysOES) String() string +``` + +#### func (*GlGenVertexArraysOES) TypeID ```go -func (o *GlGenVertexArraysOES_Postback) Decode(arrays_cnt uint64, d binary.Decoder) error +func (c *GlGenVertexArraysOES) TypeID() atom.TypeID ``` #### type GlGenerateMipmap @@ -8416,6 +13795,7 @@ func (o *GlGenVertexArraysOES_Postback) Decode(arrays_cnt uint64, d binary.Decod ```go type GlGenerateMipmap struct { binary.Generate + Target TextureImageTarget } ``` @@ -8427,9 +13807,7 @@ GlGenerateMipmap #### func NewGlGenerateMipmap ```go -func NewGlGenerateMipmap( - pTarget TextureImageTarget, -) *GlGenerateMipmap +func NewGlGenerateMipmap(Target TextureImageTarget) *GlGenerateMipmap ``` #### func (*GlGenerateMipmap) API @@ -8438,6 +13816,22 @@ func NewGlGenerateMipmap( func (c *GlGenerateMipmap) API() gfxapi.API ``` +#### func (*GlGenerateMipmap) AddRead + +```go +func (a *GlGenerateMipmap) AddRead(rng memory.Range, id binary.ID) *GlGenerateMipmap +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGenerateMipmap pointer is returned so that calls can be chained. + +#### func (*GlGenerateMipmap) AddWrite + +```go +func (a *GlGenerateMipmap) AddWrite(rng memory.Range, id binary.ID) *GlGenerateMipmap +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGenerateMipmap pointer is returned so that calls can be chained. + #### func (*GlGenerateMipmap) Class ```go @@ -8453,19 +13847,25 @@ func (c *GlGenerateMipmap) Flags() atom.Flags #### func (*GlGenerateMipmap) Mutate ```go -func (ϟa *GlGenerateMipmap) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGenerateMipmap) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGenerateMipmap) Observations + +```go +func (a *GlGenerateMipmap) Observations() *atom.Observations ``` #### func (*GlGenerateMipmap) Replay ```go -func (ϟa *GlGenerateMipmap) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGenerateMipmap) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGenerateMipmap) String ```go -func (c *GlGenerateMipmap) String() string +func (a *GlGenerateMipmap) String() string ``` #### func (*GlGenerateMipmap) TypeID @@ -8479,13 +13879,14 @@ func (c *GlGenerateMipmap) TypeID() atom.TypeID ```go type GlGetActiveAttrib struct { binary.Generate + Program ProgramId Location AttributeLocation BufferSize int32 - BufferBytesWritten int32 - VectorCount int32 - Type ShaderAttribType - Name string + BufferBytesWritten S32ᵖ + VectorCount S32ᵖ + Type ShaderAttribTypeᵖ + Name Charᵖ } ``` @@ -8496,15 +13897,7 @@ GlGetActiveAttrib #### func NewGlGetActiveAttrib ```go -func NewGlGetActiveAttrib( - pProgram ProgramId, - pLocation AttributeLocation, - pBufferSize int32, - pBufferBytesWritten int32, - pVectorCount int32, - pType ShaderAttribType, - pName string, -) *GlGetActiveAttrib +func NewGlGetActiveAttrib(Program ProgramId, Location AttributeLocation, Buffer_size int32, Buffer_bytes_written memory.Pointer, Vector_count memory.Pointer, Type memory.Pointer, Name memory.Pointer) *GlGetActiveAttrib ``` #### func (*GlGetActiveAttrib) API @@ -8513,58 +13906,62 @@ func NewGlGetActiveAttrib( func (c *GlGetActiveAttrib) API() gfxapi.API ``` -#### func (*GlGetActiveAttrib) Class +#### func (*GlGetActiveAttrib) AddRead ```go -func (*GlGetActiveAttrib) Class() binary.Class +func (a *GlGetActiveAttrib) AddRead(rng memory.Range, id binary.ID) *GlGetActiveAttrib ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetActiveAttrib pointer is returned so that calls can be chained. -#### func (*GlGetActiveAttrib) Flags +#### func (*GlGetActiveAttrib) AddWrite ```go -func (c *GlGetActiveAttrib) Flags() atom.Flags +func (a *GlGetActiveAttrib) AddWrite(rng memory.Range, id binary.ID) *GlGetActiveAttrib ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetActiveAttrib pointer is returned so that calls can be chained. -#### func (*GlGetActiveAttrib) Mutate +#### func (*GlGetActiveAttrib) Class ```go -func (ϟa *GlGetActiveAttrib) Mutate(ϟs *gfxapi.State) error +func (*GlGetActiveAttrib) Class() binary.Class ``` -#### func (*GlGetActiveAttrib) Replay +#### func (*GlGetActiveAttrib) Flags ```go -func (ϟa *GlGetActiveAttrib) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetActiveAttrib) Flags() atom.Flags ``` -#### func (*GlGetActiveAttrib) String +#### func (*GlGetActiveAttrib) Mutate ```go -func (c *GlGetActiveAttrib) String() string +func (ϟa *GlGetActiveAttrib) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetActiveAttrib) TypeID +#### func (*GlGetActiveAttrib) Observations ```go -func (c *GlGetActiveAttrib) TypeID() atom.TypeID +func (a *GlGetActiveAttrib) Observations() *atom.Observations ``` -#### type GlGetActiveAttrib_Postback +#### func (*GlGetActiveAttrib) Replay ```go -type GlGetActiveAttrib_Postback struct { - BufferBytesWritten int32 - VectorCount int32 - Type ShaderAttribType - Name string -} +func (ϟa *GlGetActiveAttrib) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetActiveAttrib) String + +```go +func (a *GlGetActiveAttrib) String() string +``` -#### func (*GlGetActiveAttrib_Postback) Decode +#### func (*GlGetActiveAttrib) TypeID ```go -func (o *GlGetActiveAttrib_Postback) Decode(name_cnt uint64, d binary.Decoder) error +func (c *GlGetActiveAttrib) TypeID() atom.TypeID ``` #### type GlGetActiveUniform @@ -8572,13 +13969,14 @@ func (o *GlGetActiveAttrib_Postback) Decode(name_cnt uint64, d binary.Decoder) e ```go type GlGetActiveUniform struct { binary.Generate + Program ProgramId Location int32 BufferSize int32 - BufferBytesWritten int32 - Size int32 - Type ShaderUniformType - Name string + BufferBytesWritten S32ᵖ + VectorCount S32ᵖ + Type ShaderUniformTypeᵖ + Name Charᵖ } ``` @@ -8589,15 +13987,7 @@ GlGetActiveUniform #### func NewGlGetActiveUniform ```go -func NewGlGetActiveUniform( - pProgram ProgramId, - pLocation int32, - pBufferSize int32, - pBufferBytesWritten int32, - pSize int32, - pType ShaderUniformType, - pName string, -) *GlGetActiveUniform +func NewGlGetActiveUniform(Program ProgramId, Location int32, Buffer_size int32, Buffer_bytes_written memory.Pointer, Vector_count memory.Pointer, Type memory.Pointer, Name memory.Pointer) *GlGetActiveUniform ``` #### func (*GlGetActiveUniform) API @@ -8606,6 +13996,24 @@ func NewGlGetActiveUniform( func (c *GlGetActiveUniform) API() gfxapi.API ``` +#### func (*GlGetActiveUniform) AddRead + +```go +func (a *GlGetActiveUniform) AddRead(rng memory.Range, id binary.ID) *GlGetActiveUniform +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetActiveUniform pointer is returned so that calls can be +chained. + +#### func (*GlGetActiveUniform) AddWrite + +```go +func (a *GlGetActiveUniform) AddWrite(rng memory.Range, id binary.ID) *GlGetActiveUniform +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetActiveUniform pointer is returned so that calls can be +chained. + #### func (*GlGetActiveUniform) Class ```go @@ -8621,19 +14029,25 @@ func (c *GlGetActiveUniform) Flags() atom.Flags #### func (*GlGetActiveUniform) Mutate ```go -func (ϟa *GlGetActiveUniform) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetActiveUniform) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetActiveUniform) Observations + +```go +func (a *GlGetActiveUniform) Observations() *atom.Observations ``` #### func (*GlGetActiveUniform) Replay ```go -func (ϟa *GlGetActiveUniform) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetActiveUniform) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetActiveUniform) String ```go -func (c *GlGetActiveUniform) String() string +func (a *GlGetActiveUniform) String() string ``` #### func (*GlGetActiveUniform) TypeID @@ -8642,22 +14056,273 @@ func (c *GlGetActiveUniform) String() string func (c *GlGetActiveUniform) TypeID() atom.TypeID ``` -#### type GlGetActiveUniform_Postback +#### type GlGetActiveUniformBlockName + +```go +type GlGetActiveUniformBlockName struct { + binary.Generate + + Program ProgramId + UniformBlockIndex uint32 + BufferSize int32 + BufferBytesWritten S32ᵖ + Name Charᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlGetActiveUniformBlockName +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlGetActiveUniformBlockName + +```go +func NewGlGetActiveUniformBlockName(Program ProgramId, Uniform_block_index uint32, Buffer_size int32, Buffer_bytes_written memory.Pointer, Name memory.Pointer) *GlGetActiveUniformBlockName +``` + +#### func (*GlGetActiveUniformBlockName) API + +```go +func (c *GlGetActiveUniformBlockName) API() gfxapi.API +``` + +#### func (*GlGetActiveUniformBlockName) AddRead + +```go +func (a *GlGetActiveUniformBlockName) AddRead(rng memory.Range, id binary.ID) *GlGetActiveUniformBlockName +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetActiveUniformBlockName pointer is returned so that calls can +be chained. + +#### func (*GlGetActiveUniformBlockName) AddWrite + +```go +func (a *GlGetActiveUniformBlockName) AddWrite(rng memory.Range, id binary.ID) *GlGetActiveUniformBlockName +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetActiveUniformBlockName pointer is returned so that calls can +be chained. + +#### func (*GlGetActiveUniformBlockName) Class + +```go +func (*GlGetActiveUniformBlockName) Class() binary.Class +``` + +#### func (*GlGetActiveUniformBlockName) Flags + +```go +func (c *GlGetActiveUniformBlockName) Flags() atom.Flags +``` + +#### func (*GlGetActiveUniformBlockName) Mutate + +```go +func (ϟa *GlGetActiveUniformBlockName) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetActiveUniformBlockName) Observations + +```go +func (a *GlGetActiveUniformBlockName) Observations() *atom.Observations +``` + +#### func (*GlGetActiveUniformBlockName) Replay + +```go +func (ϟa *GlGetActiveUniformBlockName) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGetActiveUniformBlockName) String + +```go +func (a *GlGetActiveUniformBlockName) String() string +``` + +#### func (*GlGetActiveUniformBlockName) TypeID + +```go +func (c *GlGetActiveUniformBlockName) TypeID() atom.TypeID +``` + +#### type GlGetActiveUniformBlockiv + +```go +type GlGetActiveUniformBlockiv struct { + binary.Generate + + Program ProgramId + UniformBlockIndex uint32 + ParameterName UniformBlockParameter + Parameters S32ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlGetActiveUniformBlockiv +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlGetActiveUniformBlockiv + +```go +func NewGlGetActiveUniformBlockiv(Program ProgramId, Uniform_block_index uint32, Parameter_name UniformBlockParameter, Parameters memory.Pointer) *GlGetActiveUniformBlockiv +``` + +#### func (*GlGetActiveUniformBlockiv) API + +```go +func (c *GlGetActiveUniformBlockiv) API() gfxapi.API +``` + +#### func (*GlGetActiveUniformBlockiv) AddRead + +```go +func (a *GlGetActiveUniformBlockiv) AddRead(rng memory.Range, id binary.ID) *GlGetActiveUniformBlockiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetActiveUniformBlockiv pointer is returned so that calls can be +chained. + +#### func (*GlGetActiveUniformBlockiv) AddWrite + +```go +func (a *GlGetActiveUniformBlockiv) AddWrite(rng memory.Range, id binary.ID) *GlGetActiveUniformBlockiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetActiveUniformBlockiv pointer is returned so that calls can be +chained. + +#### func (*GlGetActiveUniformBlockiv) Class ```go -type GlGetActiveUniform_Postback struct { - BufferBytesWritten int32 - Size int32 - Type ShaderUniformType - Name string +func (*GlGetActiveUniformBlockiv) Class() binary.Class +``` + +#### func (*GlGetActiveUniformBlockiv) Flags + +```go +func (c *GlGetActiveUniformBlockiv) Flags() atom.Flags +``` + +#### func (*GlGetActiveUniformBlockiv) Mutate + +```go +func (ϟa *GlGetActiveUniformBlockiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetActiveUniformBlockiv) Observations + +```go +func (a *GlGetActiveUniformBlockiv) Observations() *atom.Observations +``` + +#### func (*GlGetActiveUniformBlockiv) Replay + +```go +func (ϟa *GlGetActiveUniformBlockiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGetActiveUniformBlockiv) String + +```go +func (a *GlGetActiveUniformBlockiv) String() string +``` + +#### func (*GlGetActiveUniformBlockiv) TypeID + +```go +func (c *GlGetActiveUniformBlockiv) TypeID() atom.TypeID +``` + +#### type GlGetActiveUniformsiv + +```go +type GlGetActiveUniformsiv struct { + binary.Generate + + Program ProgramId + UniformCount uint32 + UniformIndices U32ᵖ + ParameterName UniformBlockParameter + Parameters S32ᵖ } ``` +////////////////////////////////////////////////////////////////////////////// +GlGetActiveUniformsiv +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlGetActiveUniformsiv + +```go +func NewGlGetActiveUniformsiv(Program ProgramId, Uniform_count uint32, Uniform_indices memory.Pointer, Parameter_name UniformBlockParameter, Parameters memory.Pointer) *GlGetActiveUniformsiv +``` + +#### func (*GlGetActiveUniformsiv) API + +```go +func (c *GlGetActiveUniformsiv) API() gfxapi.API +``` + +#### func (*GlGetActiveUniformsiv) AddRead + +```go +func (a *GlGetActiveUniformsiv) AddRead(rng memory.Range, id binary.ID) *GlGetActiveUniformsiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetActiveUniformsiv pointer is returned so that calls can be +chained. + +#### func (*GlGetActiveUniformsiv) AddWrite + +```go +func (a *GlGetActiveUniformsiv) AddWrite(rng memory.Range, id binary.ID) *GlGetActiveUniformsiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetActiveUniformsiv pointer is returned so that calls can be +chained. + +#### func (*GlGetActiveUniformsiv) Class + +```go +func (*GlGetActiveUniformsiv) Class() binary.Class +``` + +#### func (*GlGetActiveUniformsiv) Flags + +```go +func (c *GlGetActiveUniformsiv) Flags() atom.Flags +``` + +#### func (*GlGetActiveUniformsiv) Mutate + +```go +func (ϟa *GlGetActiveUniformsiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetActiveUniformsiv) Observations + +```go +func (a *GlGetActiveUniformsiv) Observations() *atom.Observations +``` + +#### func (*GlGetActiveUniformsiv) Replay + +```go +func (ϟa *GlGetActiveUniformsiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGetActiveUniformsiv) String -#### func (*GlGetActiveUniform_Postback) Decode +```go +func (a *GlGetActiveUniformsiv) String() string +``` + +#### func (*GlGetActiveUniformsiv) TypeID ```go -func (o *GlGetActiveUniform_Postback) Decode(name_cnt uint64, d binary.Decoder) error +func (c *GlGetActiveUniformsiv) TypeID() atom.TypeID ``` #### type GlGetAttachedShaders @@ -8665,10 +14330,11 @@ func (o *GlGetActiveUniform_Postback) Decode(name_cnt uint64, d binary.Decoder) ```go type GlGetAttachedShaders struct { binary.Generate + Program ProgramId BufferLength int32 - ShadersLengthWritten int32 - Shaders ShaderIdArray + ShadersLengthWritten S32ᵖ + Shaders ShaderIdᵖ } ``` @@ -8679,12 +14345,7 @@ GlGetAttachedShaders #### func NewGlGetAttachedShaders ```go -func NewGlGetAttachedShaders( - pProgram ProgramId, - pBufferLength int32, - pShadersLengthWritten int32, - pShaders ShaderIdArray, -) *GlGetAttachedShaders +func NewGlGetAttachedShaders(Program ProgramId, Buffer_length int32, Shaders_length_written memory.Pointer, Shaders memory.Pointer) *GlGetAttachedShaders ``` #### func (*GlGetAttachedShaders) API @@ -8693,56 +14354,64 @@ func NewGlGetAttachedShaders( func (c *GlGetAttachedShaders) API() gfxapi.API ``` -#### func (*GlGetAttachedShaders) Class +#### func (*GlGetAttachedShaders) AddRead ```go -func (*GlGetAttachedShaders) Class() binary.Class +func (a *GlGetAttachedShaders) AddRead(rng memory.Range, id binary.ID) *GlGetAttachedShaders ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetAttachedShaders pointer is returned so that calls can be +chained. -#### func (*GlGetAttachedShaders) Flags +#### func (*GlGetAttachedShaders) AddWrite ```go -func (c *GlGetAttachedShaders) Flags() atom.Flags +func (a *GlGetAttachedShaders) AddWrite(rng memory.Range, id binary.ID) *GlGetAttachedShaders ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetAttachedShaders pointer is returned so that calls can be +chained. -#### func (*GlGetAttachedShaders) Mutate +#### func (*GlGetAttachedShaders) Class ```go -func (ϟa *GlGetAttachedShaders) Mutate(ϟs *gfxapi.State) error +func (*GlGetAttachedShaders) Class() binary.Class ``` -#### func (*GlGetAttachedShaders) Replay +#### func (*GlGetAttachedShaders) Flags ```go -func (ϟa *GlGetAttachedShaders) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetAttachedShaders) Flags() atom.Flags ``` -#### func (*GlGetAttachedShaders) String +#### func (*GlGetAttachedShaders) Mutate ```go -func (c *GlGetAttachedShaders) String() string +func (ϟa *GlGetAttachedShaders) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetAttachedShaders) TypeID +#### func (*GlGetAttachedShaders) Observations ```go -func (c *GlGetAttachedShaders) TypeID() atom.TypeID +func (a *GlGetAttachedShaders) Observations() *atom.Observations ``` -#### type GlGetAttachedShaders_Postback +#### func (*GlGetAttachedShaders) Replay ```go -type GlGetAttachedShaders_Postback struct { - ShadersLengthWritten int32 - Shaders ShaderIdArray -} +func (ϟa *GlGetAttachedShaders) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetAttachedShaders) String + +```go +func (a *GlGetAttachedShaders) String() string +``` -#### func (*GlGetAttachedShaders_Postback) Decode +#### func (*GlGetAttachedShaders) TypeID ```go -func (o *GlGetAttachedShaders_Postback) Decode(shaders_cnt uint64, d binary.Decoder) error +func (c *GlGetAttachedShaders) TypeID() atom.TypeID ``` #### type GlGetAttribLocation @@ -8750,6 +14419,7 @@ func (o *GlGetAttachedShaders_Postback) Decode(shaders_cnt uint64, d binary.Deco ```go type GlGetAttribLocation struct { binary.Generate + Program ProgramId Name string Result AttributeLocation @@ -8763,11 +14433,7 @@ GlGetAttribLocation #### func NewGlGetAttribLocation ```go -func NewGlGetAttribLocation( - pProgram ProgramId, - pName string, - pResult AttributeLocation, -) *GlGetAttribLocation +func NewGlGetAttribLocation(Program ProgramId, Name string, Result AttributeLocation) *GlGetAttribLocation ``` #### func (*GlGetAttribLocation) API @@ -8776,6 +14442,24 @@ func NewGlGetAttribLocation( func (c *GlGetAttribLocation) API() gfxapi.API ``` +#### func (*GlGetAttribLocation) AddRead + +```go +func (a *GlGetAttribLocation) AddRead(rng memory.Range, id binary.ID) *GlGetAttribLocation +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetAttribLocation pointer is returned so that calls can be +chained. + +#### func (*GlGetAttribLocation) AddWrite + +```go +func (a *GlGetAttribLocation) AddWrite(rng memory.Range, id binary.ID) *GlGetAttribLocation +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetAttribLocation pointer is returned so that calls can be +chained. + #### func (*GlGetAttribLocation) Class ```go @@ -8791,13 +14475,19 @@ func (c *GlGetAttribLocation) Flags() atom.Flags #### func (*GlGetAttribLocation) Mutate ```go -func (ϟa *GlGetAttribLocation) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetAttribLocation) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetAttribLocation) Observations + +```go +func (a *GlGetAttribLocation) Observations() *atom.Observations ``` #### func (*GlGetAttribLocation) Replay ```go -func (ω *GlGetAttribLocation) Replay(id atom.ID, s *gfxapi.State, b *builder.Builder, wantOutput bool) +func (ω *GlGetAttribLocation) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` AttributeLocations cannot be remapped like UniformLocations as the VertexAttributeArrays are shared between different programs. Instead, simply @@ -8811,7 +14501,7 @@ for every call to glGetAttribLocation! #### func (*GlGetAttribLocation) String ```go -func (c *GlGetAttribLocation) String() string +func (a *GlGetAttribLocation) String() string ``` #### func (*GlGetAttribLocation) TypeID @@ -8820,28 +14510,14 @@ func (c *GlGetAttribLocation) String() string func (c *GlGetAttribLocation) TypeID() atom.TypeID ``` -#### type GlGetAttribLocation_Postback - -```go -type GlGetAttribLocation_Postback struct { - Result AttributeLocation -} -``` - - -#### func (*GlGetAttribLocation_Postback) Decode - -```go -func (o *GlGetAttribLocation_Postback) Decode(d binary.Decoder) error -``` - #### type GlGetBooleanv ```go type GlGetBooleanv struct { binary.Generate + Param StateVariable - Values BoolArray + Values Boolᵖ } ``` @@ -8852,10 +14528,7 @@ GlGetBooleanv #### func NewGlGetBooleanv ```go -func NewGlGetBooleanv( - pParam StateVariable, - pValues BoolArray, -) *GlGetBooleanv +func NewGlGetBooleanv(Param StateVariable, Values memory.Pointer) *GlGetBooleanv ``` #### func (*GlGetBooleanv) API @@ -8864,55 +14537,62 @@ func NewGlGetBooleanv( func (c *GlGetBooleanv) API() gfxapi.API ``` -#### func (*GlGetBooleanv) Class +#### func (*GlGetBooleanv) AddRead ```go -func (*GlGetBooleanv) Class() binary.Class +func (a *GlGetBooleanv) AddRead(rng memory.Range, id binary.ID) *GlGetBooleanv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetBooleanv pointer is returned so that calls can be chained. -#### func (*GlGetBooleanv) Flags +#### func (*GlGetBooleanv) AddWrite ```go -func (c *GlGetBooleanv) Flags() atom.Flags +func (a *GlGetBooleanv) AddWrite(rng memory.Range, id binary.ID) *GlGetBooleanv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetBooleanv pointer is returned so that calls can be chained. -#### func (*GlGetBooleanv) Mutate +#### func (*GlGetBooleanv) Class ```go -func (ϟa *GlGetBooleanv) Mutate(ϟs *gfxapi.State) error +func (*GlGetBooleanv) Class() binary.Class ``` -#### func (*GlGetBooleanv) Replay +#### func (*GlGetBooleanv) Flags ```go -func (ϟa *GlGetBooleanv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetBooleanv) Flags() atom.Flags ``` -#### func (*GlGetBooleanv) String +#### func (*GlGetBooleanv) Mutate ```go -func (c *GlGetBooleanv) String() string +func (ϟa *GlGetBooleanv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetBooleanv) TypeID +#### func (*GlGetBooleanv) Observations ```go -func (c *GlGetBooleanv) TypeID() atom.TypeID +func (a *GlGetBooleanv) Observations() *atom.Observations ``` -#### type GlGetBooleanv_Postback +#### func (*GlGetBooleanv) Replay ```go -type GlGetBooleanv_Postback struct { - Values BoolArray -} +func (ϟa *GlGetBooleanv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetBooleanv) String + +```go +func (a *GlGetBooleanv) String() string +``` -#### func (*GlGetBooleanv_Postback) Decode +#### func (*GlGetBooleanv) TypeID ```go -func (o *GlGetBooleanv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetBooleanv) TypeID() atom.TypeID ``` #### type GlGetBufferParameteriv @@ -8920,9 +14600,10 @@ func (o *GlGetBooleanv_Postback) Decode(values_cnt uint64, d binary.Decoder) err ```go type GlGetBufferParameteriv struct { binary.Generate + Target BufferTarget Parameter BufferParameter - Value int32 + Value S32ᵖ } ``` @@ -8933,11 +14614,7 @@ GlGetBufferParameteriv #### func NewGlGetBufferParameteriv ```go -func NewGlGetBufferParameteriv( - pTarget BufferTarget, - pParameter BufferParameter, - pValue int32, -) *GlGetBufferParameteriv +func NewGlGetBufferParameteriv(Target BufferTarget, Parameter BufferParameter, Value memory.Pointer) *GlGetBufferParameteriv ``` #### func (*GlGetBufferParameteriv) API @@ -8946,55 +14623,64 @@ func NewGlGetBufferParameteriv( func (c *GlGetBufferParameteriv) API() gfxapi.API ``` -#### func (*GlGetBufferParameteriv) Class +#### func (*GlGetBufferParameteriv) AddRead ```go -func (*GlGetBufferParameteriv) Class() binary.Class +func (a *GlGetBufferParameteriv) AddRead(rng memory.Range, id binary.ID) *GlGetBufferParameteriv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetBufferParameteriv pointer is returned so that calls can be +chained. -#### func (*GlGetBufferParameteriv) Flags +#### func (*GlGetBufferParameteriv) AddWrite ```go -func (c *GlGetBufferParameteriv) Flags() atom.Flags +func (a *GlGetBufferParameteriv) AddWrite(rng memory.Range, id binary.ID) *GlGetBufferParameteriv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetBufferParameteriv pointer is returned so that calls can be +chained. -#### func (*GlGetBufferParameteriv) Mutate +#### func (*GlGetBufferParameteriv) Class ```go -func (ϟa *GlGetBufferParameteriv) Mutate(ϟs *gfxapi.State) error +func (*GlGetBufferParameteriv) Class() binary.Class ``` -#### func (*GlGetBufferParameteriv) Replay +#### func (*GlGetBufferParameteriv) Flags ```go -func (ϟa *GlGetBufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetBufferParameteriv) Flags() atom.Flags ``` -#### func (*GlGetBufferParameteriv) String +#### func (*GlGetBufferParameteriv) Mutate ```go -func (c *GlGetBufferParameteriv) String() string +func (ϟa *GlGetBufferParameteriv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetBufferParameteriv) TypeID +#### func (*GlGetBufferParameteriv) Observations ```go -func (c *GlGetBufferParameteriv) TypeID() atom.TypeID +func (a *GlGetBufferParameteriv) Observations() *atom.Observations ``` -#### type GlGetBufferParameteriv_Postback +#### func (*GlGetBufferParameteriv) Replay ```go -type GlGetBufferParameteriv_Postback struct { - Value int32 -} +func (ϟa *GlGetBufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetBufferParameteriv) String + +```go +func (a *GlGetBufferParameteriv) String() string +``` -#### func (*GlGetBufferParameteriv_Postback) Decode +#### func (*GlGetBufferParameteriv) TypeID ```go -func (o *GlGetBufferParameteriv_Postback) Decode(d binary.Decoder) error +func (c *GlGetBufferParameteriv) TypeID() atom.TypeID ``` #### type GlGetError @@ -9002,6 +14688,7 @@ func (o *GlGetBufferParameteriv_Postback) Decode(d binary.Decoder) error ```go type GlGetError struct { binary.Generate + Result Error } ``` @@ -9013,9 +14700,7 @@ GlGetError #### func NewGlGetError ```go -func NewGlGetError( - pResult Error, -) *GlGetError +func NewGlGetError(Result Error) *GlGetError ``` #### func (*GlGetError) API @@ -9024,55 +14709,62 @@ func NewGlGetError( func (c *GlGetError) API() gfxapi.API ``` -#### func (*GlGetError) Class +#### func (*GlGetError) AddRead ```go -func (*GlGetError) Class() binary.Class +func (a *GlGetError) AddRead(rng memory.Range, id binary.ID) *GlGetError ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetError pointer is returned so that calls can be chained. -#### func (*GlGetError) Flags +#### func (*GlGetError) AddWrite ```go -func (c *GlGetError) Flags() atom.Flags +func (a *GlGetError) AddWrite(rng memory.Range, id binary.ID) *GlGetError ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetError pointer is returned so that calls can be chained. -#### func (*GlGetError) Mutate +#### func (*GlGetError) Class ```go -func (ϟa *GlGetError) Mutate(ϟs *gfxapi.State) error +func (*GlGetError) Class() binary.Class ``` -#### func (*GlGetError) Replay +#### func (*GlGetError) Flags ```go -func (ϟa *GlGetError) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetError) Flags() atom.Flags ``` -#### func (*GlGetError) String +#### func (*GlGetError) Mutate ```go -func (c *GlGetError) String() string +func (ϟa *GlGetError) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetError) TypeID +#### func (*GlGetError) Observations ```go -func (c *GlGetError) TypeID() atom.TypeID +func (a *GlGetError) Observations() *atom.Observations ``` -#### type GlGetError_Postback +#### func (*GlGetError) Replay ```go -type GlGetError_Postback struct { - Result Error -} +func (ϟa *GlGetError) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetError) String -#### func (*GlGetError_Postback) Decode +```go +func (a *GlGetError) String() string +``` + +#### func (*GlGetError) TypeID ```go -func (o *GlGetError_Postback) Decode(d binary.Decoder) error +func (c *GlGetError) TypeID() atom.TypeID ``` #### type GlGetFloatv @@ -9080,8 +14772,9 @@ func (o *GlGetError_Postback) Decode(d binary.Decoder) error ```go type GlGetFloatv struct { binary.Generate + Param StateVariable - Values F32Array + Values F32ᵖ } ``` @@ -9092,10 +14785,7 @@ GlGetFloatv #### func NewGlGetFloatv ```go -func NewGlGetFloatv( - pParam StateVariable, - pValues F32Array, -) *GlGetFloatv +func NewGlGetFloatv(Param StateVariable, Values memory.Pointer) *GlGetFloatv ``` #### func (*GlGetFloatv) API @@ -9104,55 +14794,62 @@ func NewGlGetFloatv( func (c *GlGetFloatv) API() gfxapi.API ``` -#### func (*GlGetFloatv) Class +#### func (*GlGetFloatv) AddRead ```go -func (*GlGetFloatv) Class() binary.Class +func (a *GlGetFloatv) AddRead(rng memory.Range, id binary.ID) *GlGetFloatv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetFloatv pointer is returned so that calls can be chained. -#### func (*GlGetFloatv) Flags +#### func (*GlGetFloatv) AddWrite ```go -func (c *GlGetFloatv) Flags() atom.Flags +func (a *GlGetFloatv) AddWrite(rng memory.Range, id binary.ID) *GlGetFloatv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetFloatv pointer is returned so that calls can be chained. -#### func (*GlGetFloatv) Mutate +#### func (*GlGetFloatv) Class ```go -func (ϟa *GlGetFloatv) Mutate(ϟs *gfxapi.State) error +func (*GlGetFloatv) Class() binary.Class ``` -#### func (*GlGetFloatv) Replay +#### func (*GlGetFloatv) Flags ```go -func (ϟa *GlGetFloatv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetFloatv) Flags() atom.Flags ``` -#### func (*GlGetFloatv) String +#### func (*GlGetFloatv) Mutate ```go -func (c *GlGetFloatv) String() string +func (ϟa *GlGetFloatv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetFloatv) TypeID +#### func (*GlGetFloatv) Observations ```go -func (c *GlGetFloatv) TypeID() atom.TypeID +func (a *GlGetFloatv) Observations() *atom.Observations ``` -#### type GlGetFloatv_Postback +#### func (*GlGetFloatv) Replay ```go -type GlGetFloatv_Postback struct { - Values F32Array -} +func (ϟa *GlGetFloatv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetFloatv) String + +```go +func (a *GlGetFloatv) String() string +``` -#### func (*GlGetFloatv_Postback) Decode +#### func (*GlGetFloatv) TypeID ```go -func (o *GlGetFloatv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetFloatv) TypeID() atom.TypeID ``` #### type GlGetFramebufferAttachmentParameteriv @@ -9160,10 +14857,11 @@ func (o *GlGetFloatv_Postback) Decode(values_cnt uint64, d binary.Decoder) error ```go type GlGetFramebufferAttachmentParameteriv struct { binary.Generate + FramebufferTarget FramebufferTarget Attachment FramebufferAttachment Parameter FramebufferAttachmentParameter - Value S32Array + Value S32ᵖ } ``` @@ -9174,12 +14872,7 @@ GlGetFramebufferAttachmentParameteriv #### func NewGlGetFramebufferAttachmentParameteriv ```go -func NewGlGetFramebufferAttachmentParameteriv( - pFramebufferTarget FramebufferTarget, - pAttachment FramebufferAttachment, - pParameter FramebufferAttachmentParameter, - pValue S32Array, -) *GlGetFramebufferAttachmentParameteriv +func NewGlGetFramebufferAttachmentParameteriv(Framebuffer_target FramebufferTarget, Attachment FramebufferAttachment, Parameter FramebufferAttachmentParameter, Value memory.Pointer) *GlGetFramebufferAttachmentParameteriv ``` #### func (*GlGetFramebufferAttachmentParameteriv) API @@ -9188,55 +14881,64 @@ func NewGlGetFramebufferAttachmentParameteriv( func (c *GlGetFramebufferAttachmentParameteriv) API() gfxapi.API ``` -#### func (*GlGetFramebufferAttachmentParameteriv) Class +#### func (*GlGetFramebufferAttachmentParameteriv) AddRead ```go -func (*GlGetFramebufferAttachmentParameteriv) Class() binary.Class +func (a *GlGetFramebufferAttachmentParameteriv) AddRead(rng memory.Range, id binary.ID) *GlGetFramebufferAttachmentParameteriv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetFramebufferAttachmentParameteriv pointer is returned so that +calls can be chained. -#### func (*GlGetFramebufferAttachmentParameteriv) Flags +#### func (*GlGetFramebufferAttachmentParameteriv) AddWrite ```go -func (c *GlGetFramebufferAttachmentParameteriv) Flags() atom.Flags +func (a *GlGetFramebufferAttachmentParameteriv) AddWrite(rng memory.Range, id binary.ID) *GlGetFramebufferAttachmentParameteriv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetFramebufferAttachmentParameteriv pointer is returned so that +calls can be chained. -#### func (*GlGetFramebufferAttachmentParameteriv) Mutate +#### func (*GlGetFramebufferAttachmentParameteriv) Class ```go -func (ϟa *GlGetFramebufferAttachmentParameteriv) Mutate(ϟs *gfxapi.State) error +func (*GlGetFramebufferAttachmentParameteriv) Class() binary.Class ``` -#### func (*GlGetFramebufferAttachmentParameteriv) Replay +#### func (*GlGetFramebufferAttachmentParameteriv) Flags ```go -func (ϟa *GlGetFramebufferAttachmentParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetFramebufferAttachmentParameteriv) Flags() atom.Flags ``` -#### func (*GlGetFramebufferAttachmentParameteriv) String +#### func (*GlGetFramebufferAttachmentParameteriv) Mutate ```go -func (c *GlGetFramebufferAttachmentParameteriv) String() string +func (ϟa *GlGetFramebufferAttachmentParameteriv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetFramebufferAttachmentParameteriv) TypeID +#### func (*GlGetFramebufferAttachmentParameteriv) Observations ```go -func (c *GlGetFramebufferAttachmentParameteriv) TypeID() atom.TypeID +func (a *GlGetFramebufferAttachmentParameteriv) Observations() *atom.Observations ``` -#### type GlGetFramebufferAttachmentParameteriv_Postback +#### func (*GlGetFramebufferAttachmentParameteriv) Replay ```go -type GlGetFramebufferAttachmentParameteriv_Postback struct { - Value S32Array -} +func (ϟa *GlGetFramebufferAttachmentParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetFramebufferAttachmentParameteriv) String -#### func (*GlGetFramebufferAttachmentParameteriv_Postback) Decode +```go +func (a *GlGetFramebufferAttachmentParameteriv) String() string +``` + +#### func (*GlGetFramebufferAttachmentParameteriv) TypeID ```go -func (o *GlGetFramebufferAttachmentParameteriv_Postback) Decode(value_cnt uint64, d binary.Decoder) error +func (c *GlGetFramebufferAttachmentParameteriv) TypeID() atom.TypeID ``` #### type GlGetGraphicsResetStatusEXT @@ -9244,6 +14946,7 @@ func (o *GlGetFramebufferAttachmentParameteriv_Postback) Decode(value_cnt uint64 ```go type GlGetGraphicsResetStatusEXT struct { binary.Generate + Result ResetStatus } ``` @@ -9255,9 +14958,7 @@ GlGetGraphicsResetStatusEXT #### func NewGlGetGraphicsResetStatusEXT ```go -func NewGlGetGraphicsResetStatusEXT( - pResult ResetStatus, -) *GlGetGraphicsResetStatusEXT +func NewGlGetGraphicsResetStatusEXT(Result ResetStatus) *GlGetGraphicsResetStatusEXT ``` #### func (*GlGetGraphicsResetStatusEXT) API @@ -9266,55 +14967,64 @@ func NewGlGetGraphicsResetStatusEXT( func (c *GlGetGraphicsResetStatusEXT) API() gfxapi.API ``` -#### func (*GlGetGraphicsResetStatusEXT) Class +#### func (*GlGetGraphicsResetStatusEXT) AddRead ```go -func (*GlGetGraphicsResetStatusEXT) Class() binary.Class +func (a *GlGetGraphicsResetStatusEXT) AddRead(rng memory.Range, id binary.ID) *GlGetGraphicsResetStatusEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetGraphicsResetStatusEXT pointer is returned so that calls can +be chained. -#### func (*GlGetGraphicsResetStatusEXT) Flags +#### func (*GlGetGraphicsResetStatusEXT) AddWrite ```go -func (c *GlGetGraphicsResetStatusEXT) Flags() atom.Flags +func (a *GlGetGraphicsResetStatusEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetGraphicsResetStatusEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetGraphicsResetStatusEXT pointer is returned so that calls can +be chained. -#### func (*GlGetGraphicsResetStatusEXT) Mutate +#### func (*GlGetGraphicsResetStatusEXT) Class ```go -func (ϟa *GlGetGraphicsResetStatusEXT) Mutate(ϟs *gfxapi.State) error +func (*GlGetGraphicsResetStatusEXT) Class() binary.Class ``` -#### func (*GlGetGraphicsResetStatusEXT) Replay +#### func (*GlGetGraphicsResetStatusEXT) Flags ```go -func (ϟa *GlGetGraphicsResetStatusEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetGraphicsResetStatusEXT) Flags() atom.Flags ``` -#### func (*GlGetGraphicsResetStatusEXT) String +#### func (*GlGetGraphicsResetStatusEXT) Mutate ```go -func (c *GlGetGraphicsResetStatusEXT) String() string +func (ϟa *GlGetGraphicsResetStatusEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetGraphicsResetStatusEXT) TypeID +#### func (*GlGetGraphicsResetStatusEXT) Observations ```go -func (c *GlGetGraphicsResetStatusEXT) TypeID() atom.TypeID +func (a *GlGetGraphicsResetStatusEXT) Observations() *atom.Observations ``` -#### type GlGetGraphicsResetStatusEXT_Postback +#### func (*GlGetGraphicsResetStatusEXT) Replay ```go -type GlGetGraphicsResetStatusEXT_Postback struct { - Result ResetStatus -} +func (ϟa *GlGetGraphicsResetStatusEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetGraphicsResetStatusEXT) String -#### func (*GlGetGraphicsResetStatusEXT_Postback) Decode +```go +func (a *GlGetGraphicsResetStatusEXT) String() string +``` + +#### func (*GlGetGraphicsResetStatusEXT) TypeID ```go -func (o *GlGetGraphicsResetStatusEXT_Postback) Decode(d binary.Decoder) error +func (c *GlGetGraphicsResetStatusEXT) TypeID() atom.TypeID ``` #### type GlGetIntegerv @@ -9322,8 +15032,9 @@ func (o *GlGetGraphicsResetStatusEXT_Postback) Decode(d binary.Decoder) error ```go type GlGetIntegerv struct { binary.Generate + Param StateVariable - Values S32Array + Values S32ᵖ } ``` @@ -9334,10 +15045,7 @@ GlGetIntegerv #### func NewGlGetIntegerv ```go -func NewGlGetIntegerv( - pParam StateVariable, - pValues S32Array, -) *GlGetIntegerv +func NewGlGetIntegerv(Param StateVariable, Values memory.Pointer) *GlGetIntegerv ``` #### func (*GlGetIntegerv) API @@ -9346,55 +15054,62 @@ func NewGlGetIntegerv( func (c *GlGetIntegerv) API() gfxapi.API ``` -#### func (*GlGetIntegerv) Class +#### func (*GlGetIntegerv) AddRead ```go -func (*GlGetIntegerv) Class() binary.Class +func (a *GlGetIntegerv) AddRead(rng memory.Range, id binary.ID) *GlGetIntegerv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetIntegerv pointer is returned so that calls can be chained. -#### func (*GlGetIntegerv) Flags +#### func (*GlGetIntegerv) AddWrite ```go -func (c *GlGetIntegerv) Flags() atom.Flags +func (a *GlGetIntegerv) AddWrite(rng memory.Range, id binary.ID) *GlGetIntegerv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetIntegerv pointer is returned so that calls can be chained. -#### func (*GlGetIntegerv) Mutate +#### func (*GlGetIntegerv) Class ```go -func (ϟa *GlGetIntegerv) Mutate(ϟs *gfxapi.State) error +func (*GlGetIntegerv) Class() binary.Class ``` -#### func (*GlGetIntegerv) Replay +#### func (*GlGetIntegerv) Flags ```go -func (ϟa *GlGetIntegerv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetIntegerv) Flags() atom.Flags ``` -#### func (*GlGetIntegerv) String +#### func (*GlGetIntegerv) Mutate ```go -func (c *GlGetIntegerv) String() string +func (ϟa *GlGetIntegerv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetIntegerv) TypeID +#### func (*GlGetIntegerv) Observations ```go -func (c *GlGetIntegerv) TypeID() atom.TypeID +func (a *GlGetIntegerv) Observations() *atom.Observations ``` -#### type GlGetIntegerv_Postback +#### func (*GlGetIntegerv) Replay ```go -type GlGetIntegerv_Postback struct { - Values S32Array -} +func (ϟa *GlGetIntegerv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetIntegerv) String -#### func (*GlGetIntegerv_Postback) Decode +```go +func (a *GlGetIntegerv) String() string +``` + +#### func (*GlGetIntegerv) TypeID ```go -func (o *GlGetIntegerv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetIntegerv) TypeID() atom.TypeID ``` #### type GlGetProgramBinaryOES @@ -9402,11 +15117,12 @@ func (o *GlGetIntegerv_Postback) Decode(values_cnt uint64, d binary.Decoder) err ```go type GlGetProgramBinaryOES struct { binary.Generate + Program ProgramId BufferSize int32 - BytesWritten int32 - BinaryFormat uint32 - Binary memory.Pointer + BytesWritten S32ᵖ + BinaryFormat U32ᵖ + Binary Voidᵖ } ``` @@ -9417,13 +15133,7 @@ GlGetProgramBinaryOES #### func NewGlGetProgramBinaryOES ```go -func NewGlGetProgramBinaryOES( - pProgram ProgramId, - pBufferSize int32, - pBytesWritten int32, - pBinaryFormat uint32, - pBinary memory.Pointer, -) *GlGetProgramBinaryOES +func NewGlGetProgramBinaryOES(Program ProgramId, Buffer_size int32, Bytes_written memory.Pointer, Binary_format memory.Pointer, Binary memory.Pointer) *GlGetProgramBinaryOES ``` #### func (*GlGetProgramBinaryOES) API @@ -9432,57 +15142,64 @@ func NewGlGetProgramBinaryOES( func (c *GlGetProgramBinaryOES) API() gfxapi.API ``` -#### func (*GlGetProgramBinaryOES) Class +#### func (*GlGetProgramBinaryOES) AddRead ```go -func (*GlGetProgramBinaryOES) Class() binary.Class +func (a *GlGetProgramBinaryOES) AddRead(rng memory.Range, id binary.ID) *GlGetProgramBinaryOES ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetProgramBinaryOES pointer is returned so that calls can be +chained. -#### func (*GlGetProgramBinaryOES) Flags +#### func (*GlGetProgramBinaryOES) AddWrite ```go -func (c *GlGetProgramBinaryOES) Flags() atom.Flags +func (a *GlGetProgramBinaryOES) AddWrite(rng memory.Range, id binary.ID) *GlGetProgramBinaryOES ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetProgramBinaryOES pointer is returned so that calls can be +chained. -#### func (*GlGetProgramBinaryOES) Mutate +#### func (*GlGetProgramBinaryOES) Class ```go -func (ϟa *GlGetProgramBinaryOES) Mutate(ϟs *gfxapi.State) error +func (*GlGetProgramBinaryOES) Class() binary.Class ``` -#### func (*GlGetProgramBinaryOES) Replay +#### func (*GlGetProgramBinaryOES) Flags ```go -func (ϟa *GlGetProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetProgramBinaryOES) Flags() atom.Flags ``` -#### func (*GlGetProgramBinaryOES) String +#### func (*GlGetProgramBinaryOES) Mutate ```go -func (c *GlGetProgramBinaryOES) String() string +func (ϟa *GlGetProgramBinaryOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetProgramBinaryOES) TypeID +#### func (*GlGetProgramBinaryOES) Observations ```go -func (c *GlGetProgramBinaryOES) TypeID() atom.TypeID +func (a *GlGetProgramBinaryOES) Observations() *atom.Observations ``` -#### type GlGetProgramBinaryOES_Postback +#### func (*GlGetProgramBinaryOES) Replay ```go -type GlGetProgramBinaryOES_Postback struct { - BytesWritten int32 - BinaryFormat uint32 - Binary []byte -} +func (ϟa *GlGetProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetProgramBinaryOES) String -#### func (*GlGetProgramBinaryOES_Postback) Decode +```go +func (a *GlGetProgramBinaryOES) String() string +``` + +#### func (*GlGetProgramBinaryOES) TypeID ```go -func (o *GlGetProgramBinaryOES_Postback) Decode(binary_cnt uint64, d binary.Decoder) error +func (c *GlGetProgramBinaryOES) TypeID() atom.TypeID ``` #### type GlGetProgramInfoLog @@ -9490,10 +15207,11 @@ func (o *GlGetProgramBinaryOES_Postback) Decode(binary_cnt uint64, d binary.Deco ```go type GlGetProgramInfoLog struct { binary.Generate + Program ProgramId BufferLength int32 - StringLengthWritten int32 - Info string + StringLengthWritten S32ᵖ + Info Charᵖ } ``` @@ -9504,12 +15222,7 @@ GlGetProgramInfoLog #### func NewGlGetProgramInfoLog ```go -func NewGlGetProgramInfoLog( - pProgram ProgramId, - pBufferLength int32, - pStringLengthWritten int32, - pInfo string, -) *GlGetProgramInfoLog +func NewGlGetProgramInfoLog(Program ProgramId, Buffer_length int32, String_length_written memory.Pointer, Info memory.Pointer) *GlGetProgramInfoLog ``` #### func (*GlGetProgramInfoLog) API @@ -9518,56 +15231,64 @@ func NewGlGetProgramInfoLog( func (c *GlGetProgramInfoLog) API() gfxapi.API ``` -#### func (*GlGetProgramInfoLog) Class +#### func (*GlGetProgramInfoLog) AddRead ```go -func (*GlGetProgramInfoLog) Class() binary.Class +func (a *GlGetProgramInfoLog) AddRead(rng memory.Range, id binary.ID) *GlGetProgramInfoLog ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetProgramInfoLog pointer is returned so that calls can be +chained. -#### func (*GlGetProgramInfoLog) Flags +#### func (*GlGetProgramInfoLog) AddWrite ```go -func (c *GlGetProgramInfoLog) Flags() atom.Flags +func (a *GlGetProgramInfoLog) AddWrite(rng memory.Range, id binary.ID) *GlGetProgramInfoLog ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetProgramInfoLog pointer is returned so that calls can be +chained. -#### func (*GlGetProgramInfoLog) Mutate +#### func (*GlGetProgramInfoLog) Class ```go -func (ϟa *GlGetProgramInfoLog) Mutate(ϟs *gfxapi.State) error +func (*GlGetProgramInfoLog) Class() binary.Class ``` -#### func (*GlGetProgramInfoLog) Replay +#### func (*GlGetProgramInfoLog) Flags ```go -func (ϟa *GlGetProgramInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetProgramInfoLog) Flags() atom.Flags ``` -#### func (*GlGetProgramInfoLog) String +#### func (*GlGetProgramInfoLog) Mutate ```go -func (c *GlGetProgramInfoLog) String() string +func (ϟa *GlGetProgramInfoLog) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetProgramInfoLog) TypeID +#### func (*GlGetProgramInfoLog) Observations ```go -func (c *GlGetProgramInfoLog) TypeID() atom.TypeID +func (a *GlGetProgramInfoLog) Observations() *atom.Observations ``` -#### type GlGetProgramInfoLog_Postback +#### func (*GlGetProgramInfoLog) Replay ```go -type GlGetProgramInfoLog_Postback struct { - StringLengthWritten int32 - Info string -} +func (ϟa *GlGetProgramInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetProgramInfoLog) String -#### func (*GlGetProgramInfoLog_Postback) Decode +```go +func (a *GlGetProgramInfoLog) String() string +``` + +#### func (*GlGetProgramInfoLog) TypeID ```go -func (o *GlGetProgramInfoLog_Postback) Decode(info_cnt uint64, d binary.Decoder) error +func (c *GlGetProgramInfoLog) TypeID() atom.TypeID ``` #### type GlGetProgramiv @@ -9575,9 +15296,10 @@ func (o *GlGetProgramInfoLog_Postback) Decode(info_cnt uint64, d binary.Decoder) ```go type GlGetProgramiv struct { binary.Generate + Program ProgramId Parameter ProgramParameter - Value S32Array + Value S32ᵖ } ``` @@ -9588,11 +15310,7 @@ GlGetProgramiv #### func NewGlGetProgramiv ```go -func NewGlGetProgramiv( - pProgram ProgramId, - pParameter ProgramParameter, - pValue S32Array, -) *GlGetProgramiv +func NewGlGetProgramiv(Program ProgramId, Parameter ProgramParameter, Value memory.Pointer) *GlGetProgramiv ``` #### func (*GlGetProgramiv) API @@ -9601,6 +15319,22 @@ func NewGlGetProgramiv( func (c *GlGetProgramiv) API() gfxapi.API ``` +#### func (*GlGetProgramiv) AddRead + +```go +func (a *GlGetProgramiv) AddRead(rng memory.Range, id binary.ID) *GlGetProgramiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetProgramiv pointer is returned so that calls can be chained. + +#### func (*GlGetProgramiv) AddWrite + +```go +func (a *GlGetProgramiv) AddWrite(rng memory.Range, id binary.ID) *GlGetProgramiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetProgramiv pointer is returned so that calls can be chained. + #### func (*GlGetProgramiv) Class ```go @@ -9616,19 +15350,25 @@ func (c *GlGetProgramiv) Flags() atom.Flags #### func (*GlGetProgramiv) Mutate ```go -func (ϟa *GlGetProgramiv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetProgramiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetProgramiv) Observations + +```go +func (a *GlGetProgramiv) Observations() *atom.Observations ``` #### func (*GlGetProgramiv) Replay ```go -func (ϟa *GlGetProgramiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetProgramiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetProgramiv) String ```go -func (c *GlGetProgramiv) String() string +func (a *GlGetProgramiv) String() string ``` #### func (*GlGetProgramiv) TypeID @@ -9637,19 +15377,92 @@ func (c *GlGetProgramiv) String() string func (c *GlGetProgramiv) TypeID() atom.TypeID ``` -#### type GlGetProgramiv_Postback +#### type GlGetQueryObjecti64v ```go -type GlGetProgramiv_Postback struct { - Value S32Array +type GlGetQueryObjecti64v struct { + binary.Generate + + Query QueryId + Parameter QueryObjectParameter + Value S64ᵖ } ``` +////////////////////////////////////////////////////////////////////////////// +GlGetQueryObjecti64v +////////////////////////////////////////////////////////////////////////////// -#### func (*GlGetProgramiv_Postback) Decode +#### func NewGlGetQueryObjecti64v ```go -func (o *GlGetProgramiv_Postback) Decode(value_cnt uint64, d binary.Decoder) error +func NewGlGetQueryObjecti64v(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjecti64v +``` + +#### func (*GlGetQueryObjecti64v) API + +```go +func (c *GlGetQueryObjecti64v) API() gfxapi.API +``` + +#### func (*GlGetQueryObjecti64v) AddRead + +```go +func (a *GlGetQueryObjecti64v) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjecti64v +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjecti64v pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjecti64v) AddWrite + +```go +func (a *GlGetQueryObjecti64v) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjecti64v +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjecti64v pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjecti64v) Class + +```go +func (*GlGetQueryObjecti64v) Class() binary.Class +``` + +#### func (*GlGetQueryObjecti64v) Flags + +```go +func (c *GlGetQueryObjecti64v) Flags() atom.Flags +``` + +#### func (*GlGetQueryObjecti64v) Mutate + +```go +func (ϟa *GlGetQueryObjecti64v) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetQueryObjecti64v) Observations + +```go +func (a *GlGetQueryObjecti64v) Observations() *atom.Observations +``` + +#### func (*GlGetQueryObjecti64v) Replay + +```go +func (ϟa *GlGetQueryObjecti64v) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGetQueryObjecti64v) String + +```go +func (a *GlGetQueryObjecti64v) String() string +``` + +#### func (*GlGetQueryObjecti64v) TypeID + +```go +func (c *GlGetQueryObjecti64v) TypeID() atom.TypeID ``` #### type GlGetQueryObjecti64vEXT @@ -9657,9 +15470,10 @@ func (o *GlGetProgramiv_Postback) Decode(value_cnt uint64, d binary.Decoder) err ```go type GlGetQueryObjecti64vEXT struct { binary.Generate + Query QueryId Parameter QueryObjectParameter - Value int64 + Value S64ᵖ } ``` @@ -9670,11 +15484,7 @@ GlGetQueryObjecti64vEXT #### func NewGlGetQueryObjecti64vEXT ```go -func NewGlGetQueryObjecti64vEXT( - pQuery QueryId, - pParameter QueryObjectParameter, - pValue int64, -) *GlGetQueryObjecti64vEXT +func NewGlGetQueryObjecti64vEXT(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjecti64vEXT ``` #### func (*GlGetQueryObjecti64vEXT) API @@ -9683,55 +15493,64 @@ func NewGlGetQueryObjecti64vEXT( func (c *GlGetQueryObjecti64vEXT) API() gfxapi.API ``` -#### func (*GlGetQueryObjecti64vEXT) Class +#### func (*GlGetQueryObjecti64vEXT) AddRead ```go -func (*GlGetQueryObjecti64vEXT) Class() binary.Class +func (a *GlGetQueryObjecti64vEXT) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjecti64vEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjecti64vEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjecti64vEXT) Flags +#### func (*GlGetQueryObjecti64vEXT) AddWrite ```go -func (c *GlGetQueryObjecti64vEXT) Flags() atom.Flags +func (a *GlGetQueryObjecti64vEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjecti64vEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjecti64vEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjecti64vEXT) Mutate +#### func (*GlGetQueryObjecti64vEXT) Class ```go -func (ϟa *GlGetQueryObjecti64vEXT) Mutate(ϟs *gfxapi.State) error +func (*GlGetQueryObjecti64vEXT) Class() binary.Class ``` -#### func (*GlGetQueryObjecti64vEXT) Replay +#### func (*GlGetQueryObjecti64vEXT) Flags ```go -func (ϟa *GlGetQueryObjecti64vEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetQueryObjecti64vEXT) Flags() atom.Flags ``` -#### func (*GlGetQueryObjecti64vEXT) String +#### func (*GlGetQueryObjecti64vEXT) Mutate ```go -func (c *GlGetQueryObjecti64vEXT) String() string +func (ϟa *GlGetQueryObjecti64vEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetQueryObjecti64vEXT) TypeID +#### func (*GlGetQueryObjecti64vEXT) Observations ```go -func (c *GlGetQueryObjecti64vEXT) TypeID() atom.TypeID +func (a *GlGetQueryObjecti64vEXT) Observations() *atom.Observations ``` -#### type GlGetQueryObjecti64vEXT_Postback +#### func (*GlGetQueryObjecti64vEXT) Replay ```go -type GlGetQueryObjecti64vEXT_Postback struct { - Value int64 -} +func (ϟa *GlGetQueryObjecti64vEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetQueryObjecti64vEXT) String -#### func (*GlGetQueryObjecti64vEXT_Postback) Decode +```go +func (a *GlGetQueryObjecti64vEXT) String() string +``` + +#### func (*GlGetQueryObjecti64vEXT) TypeID ```go -func (o *GlGetQueryObjecti64vEXT_Postback) Decode(d binary.Decoder) error +func (c *GlGetQueryObjecti64vEXT) TypeID() atom.TypeID ``` #### type GlGetQueryObjectivEXT @@ -9739,9 +15558,10 @@ func (o *GlGetQueryObjecti64vEXT_Postback) Decode(d binary.Decoder) error ```go type GlGetQueryObjectivEXT struct { binary.Generate + Query QueryId Parameter QueryObjectParameter - Value int32 + Value S32ᵖ } ``` @@ -9752,11 +15572,7 @@ GlGetQueryObjectivEXT #### func NewGlGetQueryObjectivEXT ```go -func NewGlGetQueryObjectivEXT( - pQuery QueryId, - pParameter QueryObjectParameter, - pValue int32, -) *GlGetQueryObjectivEXT +func NewGlGetQueryObjectivEXT(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjectivEXT ``` #### func (*GlGetQueryObjectivEXT) API @@ -9765,6 +15581,24 @@ func NewGlGetQueryObjectivEXT( func (c *GlGetQueryObjectivEXT) API() gfxapi.API ``` +#### func (*GlGetQueryObjectivEXT) AddRead + +```go +func (a *GlGetQueryObjectivEXT) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjectivEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjectivEXT pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjectivEXT) AddWrite + +```go +func (a *GlGetQueryObjectivEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjectivEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjectivEXT pointer is returned so that calls can be +chained. + #### func (*GlGetQueryObjectivEXT) Class ```go @@ -9780,19 +15614,25 @@ func (c *GlGetQueryObjectivEXT) Flags() atom.Flags #### func (*GlGetQueryObjectivEXT) Mutate ```go -func (ϟa *GlGetQueryObjectivEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetQueryObjectivEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetQueryObjectivEXT) Observations + +```go +func (a *GlGetQueryObjectivEXT) Observations() *atom.Observations ``` #### func (*GlGetQueryObjectivEXT) Replay ```go -func (ϟa *GlGetQueryObjectivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetQueryObjectivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetQueryObjectivEXT) String ```go -func (c *GlGetQueryObjectivEXT) String() string +func (a *GlGetQueryObjectivEXT) String() string ``` #### func (*GlGetQueryObjectivEXT) TypeID @@ -9801,19 +15641,92 @@ func (c *GlGetQueryObjectivEXT) String() string func (c *GlGetQueryObjectivEXT) TypeID() atom.TypeID ``` -#### type GlGetQueryObjectivEXT_Postback +#### type GlGetQueryObjectui64v ```go -type GlGetQueryObjectivEXT_Postback struct { - Value int32 +type GlGetQueryObjectui64v struct { + binary.Generate + + Query QueryId + Parameter QueryObjectParameter + Value U64ᵖ } ``` +////////////////////////////////////////////////////////////////////////////// +GlGetQueryObjectui64v +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlGetQueryObjectui64v + +```go +func NewGlGetQueryObjectui64v(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjectui64v +``` + +#### func (*GlGetQueryObjectui64v) API + +```go +func (c *GlGetQueryObjectui64v) API() gfxapi.API +``` -#### func (*GlGetQueryObjectivEXT_Postback) Decode +#### func (*GlGetQueryObjectui64v) AddRead ```go -func (o *GlGetQueryObjectivEXT_Postback) Decode(d binary.Decoder) error +func (a *GlGetQueryObjectui64v) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjectui64v +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjectui64v pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjectui64v) AddWrite + +```go +func (a *GlGetQueryObjectui64v) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjectui64v +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjectui64v pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjectui64v) Class + +```go +func (*GlGetQueryObjectui64v) Class() binary.Class +``` + +#### func (*GlGetQueryObjectui64v) Flags + +```go +func (c *GlGetQueryObjectui64v) Flags() atom.Flags +``` + +#### func (*GlGetQueryObjectui64v) Mutate + +```go +func (ϟa *GlGetQueryObjectui64v) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetQueryObjectui64v) Observations + +```go +func (a *GlGetQueryObjectui64v) Observations() *atom.Observations +``` + +#### func (*GlGetQueryObjectui64v) Replay + +```go +func (ϟa *GlGetQueryObjectui64v) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlGetQueryObjectui64v) String + +```go +func (a *GlGetQueryObjectui64v) String() string +``` + +#### func (*GlGetQueryObjectui64v) TypeID + +```go +func (c *GlGetQueryObjectui64v) TypeID() atom.TypeID ``` #### type GlGetQueryObjectui64vEXT @@ -9821,9 +15734,10 @@ func (o *GlGetQueryObjectivEXT_Postback) Decode(d binary.Decoder) error ```go type GlGetQueryObjectui64vEXT struct { binary.Generate + Query QueryId Parameter QueryObjectParameter - Value uint64 + Value U64ᵖ } ``` @@ -9834,11 +15748,7 @@ GlGetQueryObjectui64vEXT #### func NewGlGetQueryObjectui64vEXT ```go -func NewGlGetQueryObjectui64vEXT( - pQuery QueryId, - pParameter QueryObjectParameter, - pValue uint64, -) *GlGetQueryObjectui64vEXT +func NewGlGetQueryObjectui64vEXT(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjectui64vEXT ``` #### func (*GlGetQueryObjectui64vEXT) API @@ -9847,55 +15757,64 @@ func NewGlGetQueryObjectui64vEXT( func (c *GlGetQueryObjectui64vEXT) API() gfxapi.API ``` -#### func (*GlGetQueryObjectui64vEXT) Class +#### func (*GlGetQueryObjectui64vEXT) AddRead ```go -func (*GlGetQueryObjectui64vEXT) Class() binary.Class +func (a *GlGetQueryObjectui64vEXT) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjectui64vEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjectui64vEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjectui64vEXT) Flags +#### func (*GlGetQueryObjectui64vEXT) AddWrite ```go -func (c *GlGetQueryObjectui64vEXT) Flags() atom.Flags +func (a *GlGetQueryObjectui64vEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjectui64vEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjectui64vEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjectui64vEXT) Mutate +#### func (*GlGetQueryObjectui64vEXT) Class ```go -func (ϟa *GlGetQueryObjectui64vEXT) Mutate(ϟs *gfxapi.State) error +func (*GlGetQueryObjectui64vEXT) Class() binary.Class ``` -#### func (*GlGetQueryObjectui64vEXT) Replay +#### func (*GlGetQueryObjectui64vEXT) Flags ```go -func (ϟa *GlGetQueryObjectui64vEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetQueryObjectui64vEXT) Flags() atom.Flags ``` -#### func (*GlGetQueryObjectui64vEXT) String +#### func (*GlGetQueryObjectui64vEXT) Mutate ```go -func (c *GlGetQueryObjectui64vEXT) String() string +func (ϟa *GlGetQueryObjectui64vEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetQueryObjectui64vEXT) TypeID +#### func (*GlGetQueryObjectui64vEXT) Observations ```go -func (c *GlGetQueryObjectui64vEXT) TypeID() atom.TypeID +func (a *GlGetQueryObjectui64vEXT) Observations() *atom.Observations ``` -#### type GlGetQueryObjectui64vEXT_Postback +#### func (*GlGetQueryObjectui64vEXT) Replay ```go -type GlGetQueryObjectui64vEXT_Postback struct { - Value uint64 -} +func (ϟa *GlGetQueryObjectui64vEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetQueryObjectui64vEXT) String -#### func (*GlGetQueryObjectui64vEXT_Postback) Decode +```go +func (a *GlGetQueryObjectui64vEXT) String() string +``` + +#### func (*GlGetQueryObjectui64vEXT) TypeID ```go -func (o *GlGetQueryObjectui64vEXT_Postback) Decode(d binary.Decoder) error +func (c *GlGetQueryObjectui64vEXT) TypeID() atom.TypeID ``` #### type GlGetQueryObjectuiv @@ -9903,9 +15822,10 @@ func (o *GlGetQueryObjectui64vEXT_Postback) Decode(d binary.Decoder) error ```go type GlGetQueryObjectuiv struct { binary.Generate + Query QueryId Parameter QueryObjectParameter - Value uint32 + Value U32ᵖ } ``` @@ -9916,11 +15836,7 @@ GlGetQueryObjectuiv #### func NewGlGetQueryObjectuiv ```go -func NewGlGetQueryObjectuiv( - pQuery QueryId, - pParameter QueryObjectParameter, - pValue uint32, -) *GlGetQueryObjectuiv +func NewGlGetQueryObjectuiv(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjectuiv ``` #### func (*GlGetQueryObjectuiv) API @@ -9929,6 +15845,24 @@ func NewGlGetQueryObjectuiv( func (c *GlGetQueryObjectuiv) API() gfxapi.API ``` +#### func (*GlGetQueryObjectuiv) AddRead + +```go +func (a *GlGetQueryObjectuiv) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjectuiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjectuiv pointer is returned so that calls can be +chained. + +#### func (*GlGetQueryObjectuiv) AddWrite + +```go +func (a *GlGetQueryObjectuiv) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjectuiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjectuiv pointer is returned so that calls can be +chained. + #### func (*GlGetQueryObjectuiv) Class ```go @@ -9944,19 +15878,25 @@ func (c *GlGetQueryObjectuiv) Flags() atom.Flags #### func (*GlGetQueryObjectuiv) Mutate ```go -func (ϟa *GlGetQueryObjectuiv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetQueryObjectuiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetQueryObjectuiv) Observations + +```go +func (a *GlGetQueryObjectuiv) Observations() *atom.Observations ``` #### func (*GlGetQueryObjectuiv) Replay ```go -func (ϟa *GlGetQueryObjectuiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetQueryObjectuiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetQueryObjectuiv) String ```go -func (c *GlGetQueryObjectuiv) String() string +func (a *GlGetQueryObjectuiv) String() string ``` #### func (*GlGetQueryObjectuiv) TypeID @@ -9970,9 +15910,10 @@ func (c *GlGetQueryObjectuiv) TypeID() atom.TypeID ```go type GlGetQueryObjectuivEXT struct { binary.Generate + Query QueryId Parameter QueryObjectParameter - Value uint32 + Value U32ᵖ } ``` @@ -9983,11 +15924,7 @@ GlGetQueryObjectuivEXT #### func NewGlGetQueryObjectuivEXT ```go -func NewGlGetQueryObjectuivEXT( - pQuery QueryId, - pParameter QueryObjectParameter, - pValue uint32, -) *GlGetQueryObjectuivEXT +func NewGlGetQueryObjectuivEXT(Query QueryId, Parameter QueryObjectParameter, Value memory.Pointer) *GlGetQueryObjectuivEXT ``` #### func (*GlGetQueryObjectuivEXT) API @@ -9996,70 +15933,64 @@ func NewGlGetQueryObjectuivEXT( func (c *GlGetQueryObjectuivEXT) API() gfxapi.API ``` -#### func (*GlGetQueryObjectuivEXT) Class +#### func (*GlGetQueryObjectuivEXT) AddRead ```go -func (*GlGetQueryObjectuivEXT) Class() binary.Class +func (a *GlGetQueryObjectuivEXT) AddRead(rng memory.Range, id binary.ID) *GlGetQueryObjectuivEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryObjectuivEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjectuivEXT) Flags - -```go -func (c *GlGetQueryObjectuivEXT) Flags() atom.Flags -``` - -#### func (*GlGetQueryObjectuivEXT) Mutate +#### func (*GlGetQueryObjectuivEXT) AddWrite ```go -func (ϟa *GlGetQueryObjectuivEXT) Mutate(ϟs *gfxapi.State) error +func (a *GlGetQueryObjectuivEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryObjectuivEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryObjectuivEXT pointer is returned so that calls can be +chained. -#### func (*GlGetQueryObjectuivEXT) Replay +#### func (*GlGetQueryObjectuivEXT) Class ```go -func (ϟa *GlGetQueryObjectuivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (*GlGetQueryObjectuivEXT) Class() binary.Class ``` -#### func (*GlGetQueryObjectuivEXT) String +#### func (*GlGetQueryObjectuivEXT) Flags ```go -func (c *GlGetQueryObjectuivEXT) String() string +func (c *GlGetQueryObjectuivEXT) Flags() atom.Flags ``` -#### func (*GlGetQueryObjectuivEXT) TypeID +#### func (*GlGetQueryObjectuivEXT) Mutate ```go -func (c *GlGetQueryObjectuivEXT) TypeID() atom.TypeID +func (ϟa *GlGetQueryObjectuivEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type GlGetQueryObjectuivEXT_Postback +#### func (*GlGetQueryObjectuivEXT) Observations ```go -type GlGetQueryObjectuivEXT_Postback struct { - Value uint32 -} +func (a *GlGetQueryObjectuivEXT) Observations() *atom.Observations ``` - -#### func (*GlGetQueryObjectuivEXT_Postback) Decode +#### func (*GlGetQueryObjectuivEXT) Replay ```go -func (o *GlGetQueryObjectuivEXT_Postback) Decode(d binary.Decoder) error +func (ϟa *GlGetQueryObjectuivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` -#### type GlGetQueryObjectuiv_Postback +#### func (*GlGetQueryObjectuivEXT) String ```go -type GlGetQueryObjectuiv_Postback struct { - Value uint32 -} +func (a *GlGetQueryObjectuivEXT) String() string ``` - -#### func (*GlGetQueryObjectuiv_Postback) Decode +#### func (*GlGetQueryObjectuivEXT) TypeID ```go -func (o *GlGetQueryObjectuiv_Postback) Decode(d binary.Decoder) error +func (c *GlGetQueryObjectuivEXT) TypeID() atom.TypeID ``` #### type GlGetQueryiv @@ -10067,9 +15998,10 @@ func (o *GlGetQueryObjectuiv_Postback) Decode(d binary.Decoder) error ```go type GlGetQueryiv struct { binary.Generate + Target QueryTarget Parameter QueryParameter - Value int32 + Value S32ᵖ } ``` @@ -10080,11 +16012,7 @@ GlGetQueryiv #### func NewGlGetQueryiv ```go -func NewGlGetQueryiv( - pTarget QueryTarget, - pParameter QueryParameter, - pValue int32, -) *GlGetQueryiv +func NewGlGetQueryiv(Target QueryTarget, Parameter QueryParameter, Value memory.Pointer) *GlGetQueryiv ``` #### func (*GlGetQueryiv) API @@ -10093,6 +16021,22 @@ func NewGlGetQueryiv( func (c *GlGetQueryiv) API() gfxapi.API ``` +#### func (*GlGetQueryiv) AddRead + +```go +func (a *GlGetQueryiv) AddRead(rng memory.Range, id binary.ID) *GlGetQueryiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryiv pointer is returned so that calls can be chained. + +#### func (*GlGetQueryiv) AddWrite + +```go +func (a *GlGetQueryiv) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryiv pointer is returned so that calls can be chained. + #### func (*GlGetQueryiv) Class ```go @@ -10108,19 +16052,25 @@ func (c *GlGetQueryiv) Flags() atom.Flags #### func (*GlGetQueryiv) Mutate ```go -func (ϟa *GlGetQueryiv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetQueryiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetQueryiv) Observations + +```go +func (a *GlGetQueryiv) Observations() *atom.Observations ``` #### func (*GlGetQueryiv) Replay ```go -func (ϟa *GlGetQueryiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetQueryiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetQueryiv) String ```go -func (c *GlGetQueryiv) String() string +func (a *GlGetQueryiv) String() string ``` #### func (*GlGetQueryiv) TypeID @@ -10134,9 +16084,10 @@ func (c *GlGetQueryiv) TypeID() atom.TypeID ```go type GlGetQueryivEXT struct { binary.Generate + Target QueryTarget Parameter QueryParameter - Value int32 + Value S32ᵖ } ``` @@ -10147,11 +16098,7 @@ GlGetQueryivEXT #### func NewGlGetQueryivEXT ```go -func NewGlGetQueryivEXT( - pTarget QueryTarget, - pParameter QueryParameter, - pValue int32, -) *GlGetQueryivEXT +func NewGlGetQueryivEXT(Target QueryTarget, Parameter QueryParameter, Value memory.Pointer) *GlGetQueryivEXT ``` #### func (*GlGetQueryivEXT) API @@ -10160,70 +16107,62 @@ func NewGlGetQueryivEXT( func (c *GlGetQueryivEXT) API() gfxapi.API ``` -#### func (*GlGetQueryivEXT) Class - -```go -func (*GlGetQueryivEXT) Class() binary.Class -``` - -#### func (*GlGetQueryivEXT) Flags +#### func (*GlGetQueryivEXT) AddRead ```go -func (c *GlGetQueryivEXT) Flags() atom.Flags +func (a *GlGetQueryivEXT) AddRead(rng memory.Range, id binary.ID) *GlGetQueryivEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetQueryivEXT pointer is returned so that calls can be chained. -#### func (*GlGetQueryivEXT) Mutate +#### func (*GlGetQueryivEXT) AddWrite ```go -func (ϟa *GlGetQueryivEXT) Mutate(ϟs *gfxapi.State) error +func (a *GlGetQueryivEXT) AddWrite(rng memory.Range, id binary.ID) *GlGetQueryivEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetQueryivEXT pointer is returned so that calls can be chained. -#### func (*GlGetQueryivEXT) Replay +#### func (*GlGetQueryivEXT) Class ```go -func (ϟa *GlGetQueryivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (*GlGetQueryivEXT) Class() binary.Class ``` -#### func (*GlGetQueryivEXT) String +#### func (*GlGetQueryivEXT) Flags ```go -func (c *GlGetQueryivEXT) String() string +func (c *GlGetQueryivEXT) Flags() atom.Flags ``` -#### func (*GlGetQueryivEXT) TypeID +#### func (*GlGetQueryivEXT) Mutate ```go -func (c *GlGetQueryivEXT) TypeID() atom.TypeID +func (ϟa *GlGetQueryivEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type GlGetQueryivEXT_Postback +#### func (*GlGetQueryivEXT) Observations ```go -type GlGetQueryivEXT_Postback struct { - Value int32 -} +func (a *GlGetQueryivEXT) Observations() *atom.Observations ``` - -#### func (*GlGetQueryivEXT_Postback) Decode +#### func (*GlGetQueryivEXT) Replay ```go -func (o *GlGetQueryivEXT_Postback) Decode(d binary.Decoder) error +func (ϟa *GlGetQueryivEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` -#### type GlGetQueryiv_Postback +#### func (*GlGetQueryivEXT) String ```go -type GlGetQueryiv_Postback struct { - Value int32 -} +func (a *GlGetQueryivEXT) String() string ``` - -#### func (*GlGetQueryiv_Postback) Decode +#### func (*GlGetQueryivEXT) TypeID ```go -func (o *GlGetQueryiv_Postback) Decode(d binary.Decoder) error +func (c *GlGetQueryivEXT) TypeID() atom.TypeID ``` #### type GlGetRenderbufferParameteriv @@ -10231,9 +16170,10 @@ func (o *GlGetQueryiv_Postback) Decode(d binary.Decoder) error ```go type GlGetRenderbufferParameteriv struct { binary.Generate + Target RenderbufferTarget Parameter RenderbufferParameter - Values S32Array + Values S32ᵖ } ``` @@ -10244,11 +16184,7 @@ GlGetRenderbufferParameteriv #### func NewGlGetRenderbufferParameteriv ```go -func NewGlGetRenderbufferParameteriv( - pTarget RenderbufferTarget, - pParameter RenderbufferParameter, - pValues S32Array, -) *GlGetRenderbufferParameteriv +func NewGlGetRenderbufferParameteriv(Target RenderbufferTarget, Parameter RenderbufferParameter, Values memory.Pointer) *GlGetRenderbufferParameteriv ``` #### func (*GlGetRenderbufferParameteriv) API @@ -10257,55 +16193,64 @@ func NewGlGetRenderbufferParameteriv( func (c *GlGetRenderbufferParameteriv) API() gfxapi.API ``` -#### func (*GlGetRenderbufferParameteriv) Class +#### func (*GlGetRenderbufferParameteriv) AddRead ```go -func (*GlGetRenderbufferParameteriv) Class() binary.Class +func (a *GlGetRenderbufferParameteriv) AddRead(rng memory.Range, id binary.ID) *GlGetRenderbufferParameteriv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetRenderbufferParameteriv pointer is returned so that calls can +be chained. -#### func (*GlGetRenderbufferParameteriv) Flags +#### func (*GlGetRenderbufferParameteriv) AddWrite ```go -func (c *GlGetRenderbufferParameteriv) Flags() atom.Flags +func (a *GlGetRenderbufferParameteriv) AddWrite(rng memory.Range, id binary.ID) *GlGetRenderbufferParameteriv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetRenderbufferParameteriv pointer is returned so that calls can +be chained. -#### func (*GlGetRenderbufferParameteriv) Mutate +#### func (*GlGetRenderbufferParameteriv) Class ```go -func (ϟa *GlGetRenderbufferParameteriv) Mutate(ϟs *gfxapi.State) error +func (*GlGetRenderbufferParameteriv) Class() binary.Class ``` -#### func (*GlGetRenderbufferParameteriv) Replay +#### func (*GlGetRenderbufferParameteriv) Flags ```go -func (ϟa *GlGetRenderbufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetRenderbufferParameteriv) Flags() atom.Flags ``` -#### func (*GlGetRenderbufferParameteriv) String +#### func (*GlGetRenderbufferParameteriv) Mutate ```go -func (c *GlGetRenderbufferParameteriv) String() string +func (ϟa *GlGetRenderbufferParameteriv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetRenderbufferParameteriv) TypeID +#### func (*GlGetRenderbufferParameteriv) Observations ```go -func (c *GlGetRenderbufferParameteriv) TypeID() atom.TypeID +func (a *GlGetRenderbufferParameteriv) Observations() *atom.Observations ``` -#### type GlGetRenderbufferParameteriv_Postback +#### func (*GlGetRenderbufferParameteriv) Replay ```go -type GlGetRenderbufferParameteriv_Postback struct { - Values S32Array -} +func (ϟa *GlGetRenderbufferParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetRenderbufferParameteriv) String + +```go +func (a *GlGetRenderbufferParameteriv) String() string +``` -#### func (*GlGetRenderbufferParameteriv_Postback) Decode +#### func (*GlGetRenderbufferParameteriv) TypeID ```go -func (o *GlGetRenderbufferParameteriv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetRenderbufferParameteriv) TypeID() atom.TypeID ``` #### type GlGetShaderInfoLog @@ -10313,10 +16258,11 @@ func (o *GlGetRenderbufferParameteriv_Postback) Decode(values_cnt uint64, d bina ```go type GlGetShaderInfoLog struct { binary.Generate + Shader ShaderId BufferLength int32 - StringLengthWritten int32 - Info string + StringLengthWritten S32ᵖ + Info Charᵖ } ``` @@ -10327,12 +16273,7 @@ GlGetShaderInfoLog #### func NewGlGetShaderInfoLog ```go -func NewGlGetShaderInfoLog( - pShader ShaderId, - pBufferLength int32, - pStringLengthWritten int32, - pInfo string, -) *GlGetShaderInfoLog +func NewGlGetShaderInfoLog(Shader ShaderId, Buffer_length int32, String_length_written memory.Pointer, Info memory.Pointer) *GlGetShaderInfoLog ``` #### func (*GlGetShaderInfoLog) API @@ -10341,56 +16282,64 @@ func NewGlGetShaderInfoLog( func (c *GlGetShaderInfoLog) API() gfxapi.API ``` -#### func (*GlGetShaderInfoLog) Class +#### func (*GlGetShaderInfoLog) AddRead ```go -func (*GlGetShaderInfoLog) Class() binary.Class +func (a *GlGetShaderInfoLog) AddRead(rng memory.Range, id binary.ID) *GlGetShaderInfoLog ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetShaderInfoLog pointer is returned so that calls can be +chained. -#### func (*GlGetShaderInfoLog) Flags +#### func (*GlGetShaderInfoLog) AddWrite ```go -func (c *GlGetShaderInfoLog) Flags() atom.Flags +func (a *GlGetShaderInfoLog) AddWrite(rng memory.Range, id binary.ID) *GlGetShaderInfoLog ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetShaderInfoLog pointer is returned so that calls can be +chained. -#### func (*GlGetShaderInfoLog) Mutate +#### func (*GlGetShaderInfoLog) Class ```go -func (ϟa *GlGetShaderInfoLog) Mutate(ϟs *gfxapi.State) error +func (*GlGetShaderInfoLog) Class() binary.Class ``` -#### func (*GlGetShaderInfoLog) Replay +#### func (*GlGetShaderInfoLog) Flags ```go -func (ϟa *GlGetShaderInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetShaderInfoLog) Flags() atom.Flags ``` -#### func (*GlGetShaderInfoLog) String +#### func (*GlGetShaderInfoLog) Mutate ```go -func (c *GlGetShaderInfoLog) String() string +func (ϟa *GlGetShaderInfoLog) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetShaderInfoLog) TypeID +#### func (*GlGetShaderInfoLog) Observations ```go -func (c *GlGetShaderInfoLog) TypeID() atom.TypeID +func (a *GlGetShaderInfoLog) Observations() *atom.Observations ``` -#### type GlGetShaderInfoLog_Postback +#### func (*GlGetShaderInfoLog) Replay ```go -type GlGetShaderInfoLog_Postback struct { - StringLengthWritten int32 - Info string -} +func (ϟa *GlGetShaderInfoLog) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetShaderInfoLog) String -#### func (*GlGetShaderInfoLog_Postback) Decode +```go +func (a *GlGetShaderInfoLog) String() string +``` + +#### func (*GlGetShaderInfoLog) TypeID ```go -func (o *GlGetShaderInfoLog_Postback) Decode(info_cnt uint64, d binary.Decoder) error +func (c *GlGetShaderInfoLog) TypeID() atom.TypeID ``` #### type GlGetShaderPrecisionFormat @@ -10398,10 +16347,11 @@ func (o *GlGetShaderInfoLog_Postback) Decode(info_cnt uint64, d binary.Decoder) ```go type GlGetShaderPrecisionFormat struct { binary.Generate + ShaderType ShaderType PrecisionType PrecisionType - Range S32Array - Precision int32 + Range S32ᵖ + Precision S32ᵖ } ``` @@ -10412,12 +16362,7 @@ GlGetShaderPrecisionFormat #### func NewGlGetShaderPrecisionFormat ```go -func NewGlGetShaderPrecisionFormat( - pShaderType ShaderType, - pPrecisionType PrecisionType, - pRange S32Array, - pPrecision int32, -) *GlGetShaderPrecisionFormat +func NewGlGetShaderPrecisionFormat(Shader_type ShaderType, Precision_type PrecisionType, Range memory.Pointer, Precision memory.Pointer) *GlGetShaderPrecisionFormat ``` #### func (*GlGetShaderPrecisionFormat) API @@ -10426,56 +16371,64 @@ func NewGlGetShaderPrecisionFormat( func (c *GlGetShaderPrecisionFormat) API() gfxapi.API ``` -#### func (*GlGetShaderPrecisionFormat) Class +#### func (*GlGetShaderPrecisionFormat) AddRead ```go -func (*GlGetShaderPrecisionFormat) Class() binary.Class +func (a *GlGetShaderPrecisionFormat) AddRead(rng memory.Range, id binary.ID) *GlGetShaderPrecisionFormat ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetShaderPrecisionFormat pointer is returned so that calls can be +chained. -#### func (*GlGetShaderPrecisionFormat) Flags +#### func (*GlGetShaderPrecisionFormat) AddWrite ```go -func (c *GlGetShaderPrecisionFormat) Flags() atom.Flags +func (a *GlGetShaderPrecisionFormat) AddWrite(rng memory.Range, id binary.ID) *GlGetShaderPrecisionFormat ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetShaderPrecisionFormat pointer is returned so that calls can be +chained. -#### func (*GlGetShaderPrecisionFormat) Mutate +#### func (*GlGetShaderPrecisionFormat) Class ```go -func (ϟa *GlGetShaderPrecisionFormat) Mutate(ϟs *gfxapi.State) error +func (*GlGetShaderPrecisionFormat) Class() binary.Class ``` -#### func (*GlGetShaderPrecisionFormat) Replay +#### func (*GlGetShaderPrecisionFormat) Flags ```go -func (ϟa *GlGetShaderPrecisionFormat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetShaderPrecisionFormat) Flags() atom.Flags ``` -#### func (*GlGetShaderPrecisionFormat) String +#### func (*GlGetShaderPrecisionFormat) Mutate ```go -func (c *GlGetShaderPrecisionFormat) String() string +func (ϟa *GlGetShaderPrecisionFormat) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetShaderPrecisionFormat) TypeID +#### func (*GlGetShaderPrecisionFormat) Observations ```go -func (c *GlGetShaderPrecisionFormat) TypeID() atom.TypeID +func (a *GlGetShaderPrecisionFormat) Observations() *atom.Observations ``` -#### type GlGetShaderPrecisionFormat_Postback +#### func (*GlGetShaderPrecisionFormat) Replay ```go -type GlGetShaderPrecisionFormat_Postback struct { - Range S32Array - Precision int32 -} +func (ϟa *GlGetShaderPrecisionFormat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetShaderPrecisionFormat) String + +```go +func (a *GlGetShaderPrecisionFormat) String() string +``` -#### func (*GlGetShaderPrecisionFormat_Postback) Decode +#### func (*GlGetShaderPrecisionFormat) TypeID ```go -func (o *GlGetShaderPrecisionFormat_Postback) Decode(range_cnt uint64, d binary.Decoder) error +func (c *GlGetShaderPrecisionFormat) TypeID() atom.TypeID ``` #### type GlGetShaderSource @@ -10483,10 +16436,11 @@ func (o *GlGetShaderPrecisionFormat_Postback) Decode(range_cnt uint64, d binary. ```go type GlGetShaderSource struct { binary.Generate + Shader ShaderId BufferLength int32 - StringLengthWritten int32 - Source string + StringLengthWritten S32ᵖ + Source Charᵖ } ``` @@ -10497,12 +16451,7 @@ GlGetShaderSource #### func NewGlGetShaderSource ```go -func NewGlGetShaderSource( - pShader ShaderId, - pBufferLength int32, - pStringLengthWritten int32, - pSource string, -) *GlGetShaderSource +func NewGlGetShaderSource(Shader ShaderId, Buffer_length int32, String_length_written memory.Pointer, Source memory.Pointer) *GlGetShaderSource ``` #### func (*GlGetShaderSource) API @@ -10511,56 +16460,62 @@ func NewGlGetShaderSource( func (c *GlGetShaderSource) API() gfxapi.API ``` -#### func (*GlGetShaderSource) Class +#### func (*GlGetShaderSource) AddRead ```go -func (*GlGetShaderSource) Class() binary.Class +func (a *GlGetShaderSource) AddRead(rng memory.Range, id binary.ID) *GlGetShaderSource ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetShaderSource pointer is returned so that calls can be chained. -#### func (*GlGetShaderSource) Flags +#### func (*GlGetShaderSource) AddWrite ```go -func (c *GlGetShaderSource) Flags() atom.Flags +func (a *GlGetShaderSource) AddWrite(rng memory.Range, id binary.ID) *GlGetShaderSource ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetShaderSource pointer is returned so that calls can be chained. -#### func (*GlGetShaderSource) Mutate +#### func (*GlGetShaderSource) Class ```go -func (ϟa *GlGetShaderSource) Mutate(ϟs *gfxapi.State) error +func (*GlGetShaderSource) Class() binary.Class ``` -#### func (*GlGetShaderSource) Replay +#### func (*GlGetShaderSource) Flags ```go -func (ϟa *GlGetShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetShaderSource) Flags() atom.Flags ``` -#### func (*GlGetShaderSource) String +#### func (*GlGetShaderSource) Mutate ```go -func (c *GlGetShaderSource) String() string +func (ϟa *GlGetShaderSource) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetShaderSource) TypeID +#### func (*GlGetShaderSource) Observations ```go -func (c *GlGetShaderSource) TypeID() atom.TypeID +func (a *GlGetShaderSource) Observations() *atom.Observations ``` -#### type GlGetShaderSource_Postback +#### func (*GlGetShaderSource) Replay ```go -type GlGetShaderSource_Postback struct { - StringLengthWritten int32 - Source string -} +func (ϟa *GlGetShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetShaderSource) String -#### func (*GlGetShaderSource_Postback) Decode +```go +func (a *GlGetShaderSource) String() string +``` + +#### func (*GlGetShaderSource) TypeID ```go -func (o *GlGetShaderSource_Postback) Decode(source_cnt uint64, d binary.Decoder) error +func (c *GlGetShaderSource) TypeID() atom.TypeID ``` #### type GlGetShaderiv @@ -10568,9 +16523,10 @@ func (o *GlGetShaderSource_Postback) Decode(source_cnt uint64, d binary.Decoder) ```go type GlGetShaderiv struct { binary.Generate + Shader ShaderId Parameter ShaderParameter - Value S32Array + Value S32ᵖ } ``` @@ -10581,11 +16537,7 @@ GlGetShaderiv #### func NewGlGetShaderiv ```go -func NewGlGetShaderiv( - pShader ShaderId, - pParameter ShaderParameter, - pValue S32Array, -) *GlGetShaderiv +func NewGlGetShaderiv(Shader ShaderId, Parameter ShaderParameter, Value memory.Pointer) *GlGetShaderiv ``` #### func (*GlGetShaderiv) API @@ -10594,55 +16546,62 @@ func NewGlGetShaderiv( func (c *GlGetShaderiv) API() gfxapi.API ``` -#### func (*GlGetShaderiv) Class +#### func (*GlGetShaderiv) AddRead ```go -func (*GlGetShaderiv) Class() binary.Class +func (a *GlGetShaderiv) AddRead(rng memory.Range, id binary.ID) *GlGetShaderiv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetShaderiv pointer is returned so that calls can be chained. -#### func (*GlGetShaderiv) Flags +#### func (*GlGetShaderiv) AddWrite ```go -func (c *GlGetShaderiv) Flags() atom.Flags +func (a *GlGetShaderiv) AddWrite(rng memory.Range, id binary.ID) *GlGetShaderiv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetShaderiv pointer is returned so that calls can be chained. -#### func (*GlGetShaderiv) Mutate +#### func (*GlGetShaderiv) Class ```go -func (ϟa *GlGetShaderiv) Mutate(ϟs *gfxapi.State) error +func (*GlGetShaderiv) Class() binary.Class ``` -#### func (*GlGetShaderiv) Replay +#### func (*GlGetShaderiv) Flags ```go -func (ϟa *GlGetShaderiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetShaderiv) Flags() atom.Flags ``` -#### func (*GlGetShaderiv) String +#### func (*GlGetShaderiv) Mutate ```go -func (c *GlGetShaderiv) String() string +func (ϟa *GlGetShaderiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetShaderiv) TypeID +#### func (*GlGetShaderiv) Observations ```go -func (c *GlGetShaderiv) TypeID() atom.TypeID +func (a *GlGetShaderiv) Observations() *atom.Observations ``` -#### type GlGetShaderiv_Postback +#### func (*GlGetShaderiv) Replay ```go -type GlGetShaderiv_Postback struct { - Value S32Array -} +func (ϟa *GlGetShaderiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetShaderiv) String + +```go +func (a *GlGetShaderiv) String() string +``` -#### func (*GlGetShaderiv_Postback) Decode +#### func (*GlGetShaderiv) TypeID ```go -func (o *GlGetShaderiv_Postback) Decode(value_cnt uint64, d binary.Decoder) error +func (c *GlGetShaderiv) TypeID() atom.TypeID ``` #### type GlGetString @@ -10650,8 +16609,9 @@ func (o *GlGetShaderiv_Postback) Decode(value_cnt uint64, d binary.Decoder) erro ```go type GlGetString struct { binary.Generate + Param StringConstant - Result string + Result Charᵖ } ``` @@ -10662,10 +16622,7 @@ GlGetString #### func NewGlGetString ```go -func NewGlGetString( - pParam StringConstant, - pResult string, -) *GlGetString +func NewGlGetString(Param StringConstant, Result memory.Pointer) *GlGetString ``` #### func (*GlGetString) API @@ -10674,55 +16631,62 @@ func NewGlGetString( func (c *GlGetString) API() gfxapi.API ``` -#### func (*GlGetString) Class +#### func (*GlGetString) AddRead ```go -func (*GlGetString) Class() binary.Class +func (a *GlGetString) AddRead(rng memory.Range, id binary.ID) *GlGetString ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetString pointer is returned so that calls can be chained. -#### func (*GlGetString) Flags +#### func (*GlGetString) AddWrite ```go -func (c *GlGetString) Flags() atom.Flags +func (a *GlGetString) AddWrite(rng memory.Range, id binary.ID) *GlGetString ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetString pointer is returned so that calls can be chained. -#### func (*GlGetString) Mutate +#### func (*GlGetString) Class ```go -func (ϟa *GlGetString) Mutate(ϟs *gfxapi.State) error +func (*GlGetString) Class() binary.Class ``` -#### func (*GlGetString) Replay +#### func (*GlGetString) Flags ```go -func (ϟa *GlGetString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetString) Flags() atom.Flags ``` -#### func (*GlGetString) String +#### func (*GlGetString) Mutate ```go -func (c *GlGetString) String() string +func (ϟa *GlGetString) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetString) TypeID +#### func (*GlGetString) Observations ```go -func (c *GlGetString) TypeID() atom.TypeID +func (a *GlGetString) Observations() *atom.Observations ``` -#### type GlGetString_Postback +#### func (*GlGetString) Replay ```go -type GlGetString_Postback struct { - Result string -} +func (ϟa *GlGetString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetString) String + +```go +func (a *GlGetString) String() string +``` -#### func (*GlGetString_Postback) Decode +#### func (*GlGetString) TypeID ```go -func (o *GlGetString_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *GlGetString) TypeID() atom.TypeID ``` #### type GlGetTexParameterfv @@ -10730,9 +16694,10 @@ func (o *GlGetString_Postback) Decode(result_cnt uint64, d binary.Decoder) error ```go type GlGetTexParameterfv struct { binary.Generate + Target TextureTarget Parameter TextureParameter - Values F32Array + Values F32ᵖ } ``` @@ -10743,11 +16708,7 @@ GlGetTexParameterfv #### func NewGlGetTexParameterfv ```go -func NewGlGetTexParameterfv( - pTarget TextureTarget, - pParameter TextureParameter, - pValues F32Array, -) *GlGetTexParameterfv +func NewGlGetTexParameterfv(Target TextureTarget, Parameter TextureParameter, Values memory.Pointer) *GlGetTexParameterfv ``` #### func (*GlGetTexParameterfv) API @@ -10756,55 +16717,64 @@ func NewGlGetTexParameterfv( func (c *GlGetTexParameterfv) API() gfxapi.API ``` -#### func (*GlGetTexParameterfv) Class +#### func (*GlGetTexParameterfv) AddRead ```go -func (*GlGetTexParameterfv) Class() binary.Class +func (a *GlGetTexParameterfv) AddRead(rng memory.Range, id binary.ID) *GlGetTexParameterfv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetTexParameterfv pointer is returned so that calls can be +chained. -#### func (*GlGetTexParameterfv) Flags +#### func (*GlGetTexParameterfv) AddWrite ```go -func (c *GlGetTexParameterfv) Flags() atom.Flags +func (a *GlGetTexParameterfv) AddWrite(rng memory.Range, id binary.ID) *GlGetTexParameterfv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetTexParameterfv pointer is returned so that calls can be +chained. -#### func (*GlGetTexParameterfv) Mutate +#### func (*GlGetTexParameterfv) Class ```go -func (ϟa *GlGetTexParameterfv) Mutate(ϟs *gfxapi.State) error +func (*GlGetTexParameterfv) Class() binary.Class ``` -#### func (*GlGetTexParameterfv) Replay +#### func (*GlGetTexParameterfv) Flags ```go -func (ϟa *GlGetTexParameterfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetTexParameterfv) Flags() atom.Flags ``` -#### func (*GlGetTexParameterfv) String +#### func (*GlGetTexParameterfv) Mutate ```go -func (c *GlGetTexParameterfv) String() string +func (ϟa *GlGetTexParameterfv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetTexParameterfv) TypeID +#### func (*GlGetTexParameterfv) Observations ```go -func (c *GlGetTexParameterfv) TypeID() atom.TypeID +func (a *GlGetTexParameterfv) Observations() *atom.Observations ``` -#### type GlGetTexParameterfv_Postback +#### func (*GlGetTexParameterfv) Replay ```go -type GlGetTexParameterfv_Postback struct { - Values F32Array -} +func (ϟa *GlGetTexParameterfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetTexParameterfv) String -#### func (*GlGetTexParameterfv_Postback) Decode +```go +func (a *GlGetTexParameterfv) String() string +``` + +#### func (*GlGetTexParameterfv) TypeID ```go -func (o *GlGetTexParameterfv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetTexParameterfv) TypeID() atom.TypeID ``` #### type GlGetTexParameteriv @@ -10812,9 +16782,10 @@ func (o *GlGetTexParameterfv_Postback) Decode(values_cnt uint64, d binary.Decode ```go type GlGetTexParameteriv struct { binary.Generate + Target TextureTarget Parameter TextureParameter - Values S32Array + Values S32ᵖ } ``` @@ -10825,11 +16796,7 @@ GlGetTexParameteriv #### func NewGlGetTexParameteriv ```go -func NewGlGetTexParameteriv( - pTarget TextureTarget, - pParameter TextureParameter, - pValues S32Array, -) *GlGetTexParameteriv +func NewGlGetTexParameteriv(Target TextureTarget, Parameter TextureParameter, Values memory.Pointer) *GlGetTexParameteriv ``` #### func (*GlGetTexParameteriv) API @@ -10838,55 +16805,64 @@ func NewGlGetTexParameteriv( func (c *GlGetTexParameteriv) API() gfxapi.API ``` -#### func (*GlGetTexParameteriv) Class +#### func (*GlGetTexParameteriv) AddRead ```go -func (*GlGetTexParameteriv) Class() binary.Class +func (a *GlGetTexParameteriv) AddRead(rng memory.Range, id binary.ID) *GlGetTexParameteriv ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetTexParameteriv pointer is returned so that calls can be +chained. -#### func (*GlGetTexParameteriv) Flags +#### func (*GlGetTexParameteriv) AddWrite ```go -func (c *GlGetTexParameteriv) Flags() atom.Flags +func (a *GlGetTexParameteriv) AddWrite(rng memory.Range, id binary.ID) *GlGetTexParameteriv ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetTexParameteriv pointer is returned so that calls can be +chained. -#### func (*GlGetTexParameteriv) Mutate +#### func (*GlGetTexParameteriv) Class ```go -func (ϟa *GlGetTexParameteriv) Mutate(ϟs *gfxapi.State) error +func (*GlGetTexParameteriv) Class() binary.Class ``` -#### func (*GlGetTexParameteriv) Replay +#### func (*GlGetTexParameteriv) Flags ```go -func (ϟa *GlGetTexParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetTexParameteriv) Flags() atom.Flags ``` -#### func (*GlGetTexParameteriv) String +#### func (*GlGetTexParameteriv) Mutate ```go -func (c *GlGetTexParameteriv) String() string +func (ϟa *GlGetTexParameteriv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetTexParameteriv) TypeID +#### func (*GlGetTexParameteriv) Observations ```go -func (c *GlGetTexParameteriv) TypeID() atom.TypeID +func (a *GlGetTexParameteriv) Observations() *atom.Observations ``` -#### type GlGetTexParameteriv_Postback +#### func (*GlGetTexParameteriv) Replay ```go -type GlGetTexParameteriv_Postback struct { - Values S32Array -} +func (ϟa *GlGetTexParameteriv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetTexParameteriv) String + +```go +func (a *GlGetTexParameteriv) String() string +``` -#### func (*GlGetTexParameteriv_Postback) Decode +#### func (*GlGetTexParameteriv) TypeID ```go -func (o *GlGetTexParameteriv_Postback) Decode(values_cnt uint64, d binary.Decoder) error +func (c *GlGetTexParameteriv) TypeID() atom.TypeID ``` #### type GlGetUniformLocation @@ -10894,6 +16870,7 @@ func (o *GlGetTexParameteriv_Postback) Decode(values_cnt uint64, d binary.Decode ```go type GlGetUniformLocation struct { binary.Generate + Program ProgramId Name string Result UniformLocation @@ -10907,11 +16884,7 @@ GlGetUniformLocation #### func NewGlGetUniformLocation ```go -func NewGlGetUniformLocation( - pProgram ProgramId, - pName string, - pResult UniformLocation, -) *GlGetUniformLocation +func NewGlGetUniformLocation(Program ProgramId, Name string, Result UniformLocation) *GlGetUniformLocation ``` #### func (*GlGetUniformLocation) API @@ -10920,55 +16893,64 @@ func NewGlGetUniformLocation( func (c *GlGetUniformLocation) API() gfxapi.API ``` -#### func (*GlGetUniformLocation) Class +#### func (*GlGetUniformLocation) AddRead ```go -func (*GlGetUniformLocation) Class() binary.Class +func (a *GlGetUniformLocation) AddRead(rng memory.Range, id binary.ID) *GlGetUniformLocation ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetUniformLocation pointer is returned so that calls can be +chained. -#### func (*GlGetUniformLocation) Flags +#### func (*GlGetUniformLocation) AddWrite ```go -func (c *GlGetUniformLocation) Flags() atom.Flags +func (a *GlGetUniformLocation) AddWrite(rng memory.Range, id binary.ID) *GlGetUniformLocation ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetUniformLocation pointer is returned so that calls can be +chained. -#### func (*GlGetUniformLocation) Mutate +#### func (*GlGetUniformLocation) Class ```go -func (ϟa *GlGetUniformLocation) Mutate(ϟs *gfxapi.State) error +func (*GlGetUniformLocation) Class() binary.Class ``` -#### func (*GlGetUniformLocation) Replay +#### func (*GlGetUniformLocation) Flags ```go -func (ϟa *GlGetUniformLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlGetUniformLocation) Flags() atom.Flags ``` -#### func (*GlGetUniformLocation) String +#### func (*GlGetUniformLocation) Mutate ```go -func (c *GlGetUniformLocation) String() string +func (ϟa *GlGetUniformLocation) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlGetUniformLocation) TypeID +#### func (*GlGetUniformLocation) Observations ```go -func (c *GlGetUniformLocation) TypeID() atom.TypeID +func (a *GlGetUniformLocation) Observations() *atom.Observations ``` -#### type GlGetUniformLocation_Postback +#### func (*GlGetUniformLocation) Replay ```go -type GlGetUniformLocation_Postback struct { - Result UniformLocation -} +func (ϟa *GlGetUniformLocation) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlGetUniformLocation) String + +```go +func (a *GlGetUniformLocation) String() string +``` -#### func (*GlGetUniformLocation_Postback) Decode +#### func (*GlGetUniformLocation) TypeID ```go -func (o *GlGetUniformLocation_Postback) Decode(d binary.Decoder) error +func (c *GlGetUniformLocation) TypeID() atom.TypeID ``` #### type GlGetUniformfv @@ -10976,9 +16958,10 @@ func (o *GlGetUniformLocation_Postback) Decode(d binary.Decoder) error ```go type GlGetUniformfv struct { binary.Generate + Program ProgramId Location UniformLocation - Values F32Array + Values F32ᵖ } ``` @@ -10989,11 +16972,7 @@ GlGetUniformfv #### func NewGlGetUniformfv ```go -func NewGlGetUniformfv( - pProgram ProgramId, - pLocation UniformLocation, - pValues F32Array, -) *GlGetUniformfv +func NewGlGetUniformfv(Program ProgramId, Location UniformLocation, Values memory.Pointer) *GlGetUniformfv ``` #### func (*GlGetUniformfv) API @@ -11002,6 +16981,22 @@ func NewGlGetUniformfv( func (c *GlGetUniformfv) API() gfxapi.API ``` +#### func (*GlGetUniformfv) AddRead + +```go +func (a *GlGetUniformfv) AddRead(rng memory.Range, id binary.ID) *GlGetUniformfv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetUniformfv pointer is returned so that calls can be chained. + +#### func (*GlGetUniformfv) AddWrite + +```go +func (a *GlGetUniformfv) AddWrite(rng memory.Range, id binary.ID) *GlGetUniformfv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetUniformfv pointer is returned so that calls can be chained. + #### func (*GlGetUniformfv) Class ```go @@ -11017,19 +17012,25 @@ func (c *GlGetUniformfv) Flags() atom.Flags #### func (*GlGetUniformfv) Mutate ```go -func (ϟa *GlGetUniformfv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetUniformfv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetUniformfv) Observations + +```go +func (a *GlGetUniformfv) Observations() *atom.Observations ``` #### func (*GlGetUniformfv) Replay ```go -func (ϟa *GlGetUniformfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetUniformfv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetUniformfv) String ```go -func (c *GlGetUniformfv) String() string +func (a *GlGetUniformfv) String() string ``` #### func (*GlGetUniformfv) TypeID @@ -11043,9 +17044,10 @@ func (c *GlGetUniformfv) TypeID() atom.TypeID ```go type GlGetUniformiv struct { binary.Generate + Program ProgramId Location UniformLocation - Values S32Array + Values S32ᵖ } ``` @@ -11056,11 +17058,7 @@ GlGetUniformiv #### func NewGlGetUniformiv ```go -func NewGlGetUniformiv( - pProgram ProgramId, - pLocation UniformLocation, - pValues S32Array, -) *GlGetUniformiv +func NewGlGetUniformiv(Program ProgramId, Location UniformLocation, Values memory.Pointer) *GlGetUniformiv ``` #### func (*GlGetUniformiv) API @@ -11069,6 +17067,22 @@ func NewGlGetUniformiv( func (c *GlGetUniformiv) API() gfxapi.API ``` +#### func (*GlGetUniformiv) AddRead + +```go +func (a *GlGetUniformiv) AddRead(rng memory.Range, id binary.ID) *GlGetUniformiv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlGetUniformiv pointer is returned so that calls can be chained. + +#### func (*GlGetUniformiv) AddWrite + +```go +func (a *GlGetUniformiv) AddWrite(rng memory.Range, id binary.ID) *GlGetUniformiv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlGetUniformiv pointer is returned so that calls can be chained. + #### func (*GlGetUniformiv) Class ```go @@ -11084,19 +17098,25 @@ func (c *GlGetUniformiv) Flags() atom.Flags #### func (*GlGetUniformiv) Mutate ```go -func (ϟa *GlGetUniformiv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlGetUniformiv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlGetUniformiv) Observations + +```go +func (a *GlGetUniformiv) Observations() *atom.Observations ``` #### func (*GlGetUniformiv) Replay ```go -func (ϟa *GlGetUniformiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlGetUniformiv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlGetUniformiv) String ```go -func (c *GlGetUniformiv) String() string +func (a *GlGetUniformiv) String() string ``` #### func (*GlGetUniformiv) TypeID @@ -11110,6 +17130,7 @@ func (c *GlGetUniformiv) TypeID() atom.TypeID ```go type GlHint struct { binary.Generate + Target HintTarget Mode HintMode } @@ -11122,10 +17143,7 @@ GlHint #### func NewGlHint ```go -func NewGlHint( - pTarget HintTarget, - pMode HintMode, -) *GlHint +func NewGlHint(Target HintTarget, Mode HintMode) *GlHint ``` #### func (*GlHint) API @@ -11134,6 +17152,22 @@ func NewGlHint( func (c *GlHint) API() gfxapi.API ``` +#### func (*GlHint) AddRead + +```go +func (a *GlHint) AddRead(rng memory.Range, id binary.ID) *GlHint +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlHint pointer is returned so that calls can be chained. + +#### func (*GlHint) AddWrite + +```go +func (a *GlHint) AddWrite(rng memory.Range, id binary.ID) *GlHint +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlHint pointer is returned so that calls can be chained. + #### func (*GlHint) Class ```go @@ -11149,19 +17183,25 @@ func (c *GlHint) Flags() atom.Flags #### func (*GlHint) Mutate ```go -func (ϟa *GlHint) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlHint) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlHint) Observations + +```go +func (a *GlHint) Observations() *atom.Observations ``` #### func (*GlHint) Replay ```go -func (ϟa *GlHint) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlHint) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlHint) String ```go -func (c *GlHint) String() string +func (a *GlHint) String() string ``` #### func (*GlHint) TypeID @@ -11175,8 +17215,9 @@ func (c *GlHint) TypeID() atom.TypeID ```go type GlInsertEventMarkerEXT struct { binary.Generate + Length int32 - Marker string + Marker Charᵖ } ``` @@ -11187,10 +17228,7 @@ GlInsertEventMarkerEXT #### func NewGlInsertEventMarkerEXT ```go -func NewGlInsertEventMarkerEXT( - pLength int32, - pMarker string, -) *GlInsertEventMarkerEXT +func NewGlInsertEventMarkerEXT(Length int32, Marker memory.Pointer) *GlInsertEventMarkerEXT ``` #### func (*GlInsertEventMarkerEXT) API @@ -11199,6 +17237,24 @@ func NewGlInsertEventMarkerEXT( func (c *GlInsertEventMarkerEXT) API() gfxapi.API ``` +#### func (*GlInsertEventMarkerEXT) AddRead + +```go +func (a *GlInsertEventMarkerEXT) AddRead(rng memory.Range, id binary.ID) *GlInsertEventMarkerEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlInsertEventMarkerEXT pointer is returned so that calls can be +chained. + +#### func (*GlInsertEventMarkerEXT) AddWrite + +```go +func (a *GlInsertEventMarkerEXT) AddWrite(rng memory.Range, id binary.ID) *GlInsertEventMarkerEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlInsertEventMarkerEXT pointer is returned so that calls can be +chained. + #### func (*GlInsertEventMarkerEXT) Class ```go @@ -11214,19 +17270,25 @@ func (c *GlInsertEventMarkerEXT) Flags() atom.Flags #### func (*GlInsertEventMarkerEXT) Mutate ```go -func (ϟa *GlInsertEventMarkerEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlInsertEventMarkerEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlInsertEventMarkerEXT) Observations + +```go +func (a *GlInsertEventMarkerEXT) Observations() *atom.Observations ``` #### func (*GlInsertEventMarkerEXT) Replay ```go -func (ϟa *GlInsertEventMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlInsertEventMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlInsertEventMarkerEXT) String ```go -func (c *GlInsertEventMarkerEXT) String() string +func (a *GlInsertEventMarkerEXT) String() string ``` #### func (*GlInsertEventMarkerEXT) TypeID @@ -11240,9 +17302,10 @@ func (c *GlInsertEventMarkerEXT) TypeID() atom.TypeID ```go type GlInvalidateFramebuffer struct { binary.Generate + Target FramebufferTarget Count int32 - Attachments FramebufferAttachmentArray + Attachments FramebufferAttachmentᵖ } ``` @@ -11253,11 +17316,7 @@ GlInvalidateFramebuffer #### func NewGlInvalidateFramebuffer ```go -func NewGlInvalidateFramebuffer( - pTarget FramebufferTarget, - pCount int32, - pAttachments FramebufferAttachmentArray, -) *GlInvalidateFramebuffer +func NewGlInvalidateFramebuffer(Target FramebufferTarget, Count int32, Attachments memory.Pointer) *GlInvalidateFramebuffer ``` #### func (*GlInvalidateFramebuffer) API @@ -11266,6 +17325,24 @@ func NewGlInvalidateFramebuffer( func (c *GlInvalidateFramebuffer) API() gfxapi.API ``` +#### func (*GlInvalidateFramebuffer) AddRead + +```go +func (a *GlInvalidateFramebuffer) AddRead(rng memory.Range, id binary.ID) *GlInvalidateFramebuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlInvalidateFramebuffer pointer is returned so that calls can be +chained. + +#### func (*GlInvalidateFramebuffer) AddWrite + +```go +func (a *GlInvalidateFramebuffer) AddWrite(rng memory.Range, id binary.ID) *GlInvalidateFramebuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlInvalidateFramebuffer pointer is returned so that calls can be +chained. + #### func (*GlInvalidateFramebuffer) Class ```go @@ -11281,19 +17358,25 @@ func (c *GlInvalidateFramebuffer) Flags() atom.Flags #### func (*GlInvalidateFramebuffer) Mutate ```go -func (ϟa *GlInvalidateFramebuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlInvalidateFramebuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlInvalidateFramebuffer) Observations + +```go +func (a *GlInvalidateFramebuffer) Observations() *atom.Observations ``` #### func (*GlInvalidateFramebuffer) Replay ```go -func (ϟa *GlInvalidateFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlInvalidateFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlInvalidateFramebuffer) String ```go -func (c *GlInvalidateFramebuffer) String() string +func (a *GlInvalidateFramebuffer) String() string ``` #### func (*GlInvalidateFramebuffer) TypeID @@ -11307,6 +17390,7 @@ func (c *GlInvalidateFramebuffer) TypeID() atom.TypeID ```go type GlIsBuffer struct { binary.Generate + Buffer BufferId Result bool } @@ -11319,10 +17403,7 @@ GlIsBuffer #### func NewGlIsBuffer ```go -func NewGlIsBuffer( - pBuffer BufferId, - pResult bool, -) *GlIsBuffer +func NewGlIsBuffer(Buffer BufferId, Result bool) *GlIsBuffer ``` #### func (*GlIsBuffer) API @@ -11331,55 +17412,62 @@ func NewGlIsBuffer( func (c *GlIsBuffer) API() gfxapi.API ``` -#### func (*GlIsBuffer) Class +#### func (*GlIsBuffer) AddRead ```go -func (*GlIsBuffer) Class() binary.Class +func (a *GlIsBuffer) AddRead(rng memory.Range, id binary.ID) *GlIsBuffer ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsBuffer pointer is returned so that calls can be chained. -#### func (*GlIsBuffer) Flags +#### func (*GlIsBuffer) AddWrite ```go -func (c *GlIsBuffer) Flags() atom.Flags +func (a *GlIsBuffer) AddWrite(rng memory.Range, id binary.ID) *GlIsBuffer ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsBuffer pointer is returned so that calls can be chained. -#### func (*GlIsBuffer) Mutate +#### func (*GlIsBuffer) Class ```go -func (ϟa *GlIsBuffer) Mutate(ϟs *gfxapi.State) error +func (*GlIsBuffer) Class() binary.Class ``` -#### func (*GlIsBuffer) Replay +#### func (*GlIsBuffer) Flags ```go -func (ϟa *GlIsBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsBuffer) Flags() atom.Flags ``` -#### func (*GlIsBuffer) String +#### func (*GlIsBuffer) Mutate ```go -func (c *GlIsBuffer) String() string +func (ϟa *GlIsBuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsBuffer) TypeID +#### func (*GlIsBuffer) Observations ```go -func (c *GlIsBuffer) TypeID() atom.TypeID +func (a *GlIsBuffer) Observations() *atom.Observations ``` -#### type GlIsBuffer_Postback +#### func (*GlIsBuffer) Replay ```go -type GlIsBuffer_Postback struct { - Result bool -} +func (ϟa *GlIsBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsBuffer) String + +```go +func (a *GlIsBuffer) String() string +``` -#### func (*GlIsBuffer_Postback) Decode +#### func (*GlIsBuffer) TypeID ```go -func (o *GlIsBuffer_Postback) Decode(d binary.Decoder) error +func (c *GlIsBuffer) TypeID() atom.TypeID ``` #### type GlIsEnabled @@ -11387,6 +17475,7 @@ func (o *GlIsBuffer_Postback) Decode(d binary.Decoder) error ```go type GlIsEnabled struct { binary.Generate + Capability Capability Result bool } @@ -11399,10 +17488,7 @@ GlIsEnabled #### func NewGlIsEnabled ```go -func NewGlIsEnabled( - pCapability Capability, - pResult bool, -) *GlIsEnabled +func NewGlIsEnabled(Capability Capability, Result bool) *GlIsEnabled ``` #### func (*GlIsEnabled) API @@ -11411,55 +17497,62 @@ func NewGlIsEnabled( func (c *GlIsEnabled) API() gfxapi.API ``` -#### func (*GlIsEnabled) Class +#### func (*GlIsEnabled) AddRead ```go -func (*GlIsEnabled) Class() binary.Class +func (a *GlIsEnabled) AddRead(rng memory.Range, id binary.ID) *GlIsEnabled ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsEnabled pointer is returned so that calls can be chained. -#### func (*GlIsEnabled) Flags +#### func (*GlIsEnabled) AddWrite ```go -func (c *GlIsEnabled) Flags() atom.Flags +func (a *GlIsEnabled) AddWrite(rng memory.Range, id binary.ID) *GlIsEnabled ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsEnabled pointer is returned so that calls can be chained. -#### func (*GlIsEnabled) Mutate +#### func (*GlIsEnabled) Class ```go -func (ϟa *GlIsEnabled) Mutate(ϟs *gfxapi.State) error +func (*GlIsEnabled) Class() binary.Class ``` -#### func (*GlIsEnabled) Replay +#### func (*GlIsEnabled) Flags ```go -func (ϟa *GlIsEnabled) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsEnabled) Flags() atom.Flags ``` -#### func (*GlIsEnabled) String +#### func (*GlIsEnabled) Mutate ```go -func (c *GlIsEnabled) String() string +func (ϟa *GlIsEnabled) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsEnabled) TypeID +#### func (*GlIsEnabled) Observations ```go -func (c *GlIsEnabled) TypeID() atom.TypeID +func (a *GlIsEnabled) Observations() *atom.Observations ``` -#### type GlIsEnabled_Postback +#### func (*GlIsEnabled) Replay ```go -type GlIsEnabled_Postback struct { - Result bool -} +func (ϟa *GlIsEnabled) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsEnabled) String -#### func (*GlIsEnabled_Postback) Decode +```go +func (a *GlIsEnabled) String() string +``` + +#### func (*GlIsEnabled) TypeID ```go -func (o *GlIsEnabled_Postback) Decode(d binary.Decoder) error +func (c *GlIsEnabled) TypeID() atom.TypeID ``` #### type GlIsFramebuffer @@ -11467,6 +17560,7 @@ func (o *GlIsEnabled_Postback) Decode(d binary.Decoder) error ```go type GlIsFramebuffer struct { binary.Generate + Framebuffer FramebufferId Result bool } @@ -11479,10 +17573,7 @@ GlIsFramebuffer #### func NewGlIsFramebuffer ```go -func NewGlIsFramebuffer( - pFramebuffer FramebufferId, - pResult bool, -) *GlIsFramebuffer +func NewGlIsFramebuffer(Framebuffer FramebufferId, Result bool) *GlIsFramebuffer ``` #### func (*GlIsFramebuffer) API @@ -11491,55 +17582,62 @@ func NewGlIsFramebuffer( func (c *GlIsFramebuffer) API() gfxapi.API ``` -#### func (*GlIsFramebuffer) Class +#### func (*GlIsFramebuffer) AddRead ```go -func (*GlIsFramebuffer) Class() binary.Class +func (a *GlIsFramebuffer) AddRead(rng memory.Range, id binary.ID) *GlIsFramebuffer ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsFramebuffer pointer is returned so that calls can be chained. -#### func (*GlIsFramebuffer) Flags +#### func (*GlIsFramebuffer) AddWrite ```go -func (c *GlIsFramebuffer) Flags() atom.Flags +func (a *GlIsFramebuffer) AddWrite(rng memory.Range, id binary.ID) *GlIsFramebuffer ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsFramebuffer pointer is returned so that calls can be chained. -#### func (*GlIsFramebuffer) Mutate +#### func (*GlIsFramebuffer) Class ```go -func (ϟa *GlIsFramebuffer) Mutate(ϟs *gfxapi.State) error +func (*GlIsFramebuffer) Class() binary.Class ``` -#### func (*GlIsFramebuffer) Replay +#### func (*GlIsFramebuffer) Flags ```go -func (ϟa *GlIsFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsFramebuffer) Flags() atom.Flags ``` -#### func (*GlIsFramebuffer) String +#### func (*GlIsFramebuffer) Mutate ```go -func (c *GlIsFramebuffer) String() string +func (ϟa *GlIsFramebuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsFramebuffer) TypeID +#### func (*GlIsFramebuffer) Observations ```go -func (c *GlIsFramebuffer) TypeID() atom.TypeID +func (a *GlIsFramebuffer) Observations() *atom.Observations ``` -#### type GlIsFramebuffer_Postback +#### func (*GlIsFramebuffer) Replay ```go -type GlIsFramebuffer_Postback struct { - Result bool -} +func (ϟa *GlIsFramebuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsFramebuffer) String + +```go +func (a *GlIsFramebuffer) String() string +``` -#### func (*GlIsFramebuffer_Postback) Decode +#### func (*GlIsFramebuffer) TypeID ```go -func (o *GlIsFramebuffer_Postback) Decode(d binary.Decoder) error +func (c *GlIsFramebuffer) TypeID() atom.TypeID ``` #### type GlIsProgram @@ -11547,6 +17645,7 @@ func (o *GlIsFramebuffer_Postback) Decode(d binary.Decoder) error ```go type GlIsProgram struct { binary.Generate + Program ProgramId Result bool } @@ -11559,10 +17658,7 @@ GlIsProgram #### func NewGlIsProgram ```go -func NewGlIsProgram( - pProgram ProgramId, - pResult bool, -) *GlIsProgram +func NewGlIsProgram(Program ProgramId, Result bool) *GlIsProgram ``` #### func (*GlIsProgram) API @@ -11571,55 +17667,62 @@ func NewGlIsProgram( func (c *GlIsProgram) API() gfxapi.API ``` -#### func (*GlIsProgram) Class +#### func (*GlIsProgram) AddRead ```go -func (*GlIsProgram) Class() binary.Class +func (a *GlIsProgram) AddRead(rng memory.Range, id binary.ID) *GlIsProgram ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsProgram pointer is returned so that calls can be chained. -#### func (*GlIsProgram) Flags +#### func (*GlIsProgram) AddWrite ```go -func (c *GlIsProgram) Flags() atom.Flags +func (a *GlIsProgram) AddWrite(rng memory.Range, id binary.ID) *GlIsProgram ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsProgram pointer is returned so that calls can be chained. -#### func (*GlIsProgram) Mutate +#### func (*GlIsProgram) Class ```go -func (ϟa *GlIsProgram) Mutate(ϟs *gfxapi.State) error +func (*GlIsProgram) Class() binary.Class ``` -#### func (*GlIsProgram) Replay +#### func (*GlIsProgram) Flags ```go -func (ϟa *GlIsProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsProgram) Flags() atom.Flags ``` -#### func (*GlIsProgram) String +#### func (*GlIsProgram) Mutate ```go -func (c *GlIsProgram) String() string +func (ϟa *GlIsProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsProgram) TypeID +#### func (*GlIsProgram) Observations ```go -func (c *GlIsProgram) TypeID() atom.TypeID +func (a *GlIsProgram) Observations() *atom.Observations ``` -#### type GlIsProgram_Postback +#### func (*GlIsProgram) Replay ```go -type GlIsProgram_Postback struct { - Result bool -} +func (ϟa *GlIsProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsProgram) String -#### func (*GlIsProgram_Postback) Decode +```go +func (a *GlIsProgram) String() string +``` + +#### func (*GlIsProgram) TypeID ```go -func (o *GlIsProgram_Postback) Decode(d binary.Decoder) error +func (c *GlIsProgram) TypeID() atom.TypeID ``` #### type GlIsQuery @@ -11627,6 +17730,7 @@ func (o *GlIsProgram_Postback) Decode(d binary.Decoder) error ```go type GlIsQuery struct { binary.Generate + Query QueryId Result bool } @@ -11639,10 +17743,7 @@ GlIsQuery #### func NewGlIsQuery ```go -func NewGlIsQuery( - pQuery QueryId, - pResult bool, -) *GlIsQuery +func NewGlIsQuery(Query QueryId, Result bool) *GlIsQuery ``` #### func (*GlIsQuery) API @@ -11651,6 +17752,22 @@ func NewGlIsQuery( func (c *GlIsQuery) API() gfxapi.API ``` +#### func (*GlIsQuery) AddRead + +```go +func (a *GlIsQuery) AddRead(rng memory.Range, id binary.ID) *GlIsQuery +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsQuery pointer is returned so that calls can be chained. + +#### func (*GlIsQuery) AddWrite + +```go +func (a *GlIsQuery) AddWrite(rng memory.Range, id binary.ID) *GlIsQuery +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsQuery pointer is returned so that calls can be chained. + #### func (*GlIsQuery) Class ```go @@ -11666,19 +17783,25 @@ func (c *GlIsQuery) Flags() atom.Flags #### func (*GlIsQuery) Mutate ```go -func (ϟa *GlIsQuery) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlIsQuery) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlIsQuery) Observations + +```go +func (a *GlIsQuery) Observations() *atom.Observations ``` #### func (*GlIsQuery) Replay ```go -func (ϟa *GlIsQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlIsQuery) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlIsQuery) String ```go -func (c *GlIsQuery) String() string +func (a *GlIsQuery) String() string ``` #### func (*GlIsQuery) TypeID @@ -11692,6 +17815,7 @@ func (c *GlIsQuery) TypeID() atom.TypeID ```go type GlIsQueryEXT struct { binary.Generate + Query QueryId Result bool } @@ -11704,10 +17828,7 @@ GlIsQueryEXT #### func NewGlIsQueryEXT ```go -func NewGlIsQueryEXT( - pQuery QueryId, - pResult bool, -) *GlIsQueryEXT +func NewGlIsQueryEXT(Query QueryId, Result bool) *GlIsQueryEXT ``` #### func (*GlIsQueryEXT) API @@ -11716,70 +17837,62 @@ func NewGlIsQueryEXT( func (c *GlIsQueryEXT) API() gfxapi.API ``` -#### func (*GlIsQueryEXT) Class - -```go -func (*GlIsQueryEXT) Class() binary.Class -``` - -#### func (*GlIsQueryEXT) Flags +#### func (*GlIsQueryEXT) AddRead ```go -func (c *GlIsQueryEXT) Flags() atom.Flags +func (a *GlIsQueryEXT) AddRead(rng memory.Range, id binary.ID) *GlIsQueryEXT ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsQueryEXT pointer is returned so that calls can be chained. -#### func (*GlIsQueryEXT) Mutate +#### func (*GlIsQueryEXT) AddWrite ```go -func (ϟa *GlIsQueryEXT) Mutate(ϟs *gfxapi.State) error +func (a *GlIsQueryEXT) AddWrite(rng memory.Range, id binary.ID) *GlIsQueryEXT ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsQueryEXT pointer is returned so that calls can be chained. -#### func (*GlIsQueryEXT) Replay +#### func (*GlIsQueryEXT) Class ```go -func (ϟa *GlIsQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (*GlIsQueryEXT) Class() binary.Class ``` -#### func (*GlIsQueryEXT) String +#### func (*GlIsQueryEXT) Flags ```go -func (c *GlIsQueryEXT) String() string +func (c *GlIsQueryEXT) Flags() atom.Flags ``` -#### func (*GlIsQueryEXT) TypeID +#### func (*GlIsQueryEXT) Mutate ```go -func (c *GlIsQueryEXT) TypeID() atom.TypeID +func (ϟa *GlIsQueryEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type GlIsQueryEXT_Postback +#### func (*GlIsQueryEXT) Observations ```go -type GlIsQueryEXT_Postback struct { - Result bool -} +func (a *GlIsQueryEXT) Observations() *atom.Observations ``` - -#### func (*GlIsQueryEXT_Postback) Decode +#### func (*GlIsQueryEXT) Replay ```go -func (o *GlIsQueryEXT_Postback) Decode(d binary.Decoder) error +func (ϟa *GlIsQueryEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` -#### type GlIsQuery_Postback +#### func (*GlIsQueryEXT) String ```go -type GlIsQuery_Postback struct { - Result bool -} +func (a *GlIsQueryEXT) String() string ``` - -#### func (*GlIsQuery_Postback) Decode +#### func (*GlIsQueryEXT) TypeID ```go -func (o *GlIsQuery_Postback) Decode(d binary.Decoder) error +func (c *GlIsQueryEXT) TypeID() atom.TypeID ``` #### type GlIsRenderbuffer @@ -11787,6 +17900,7 @@ func (o *GlIsQuery_Postback) Decode(d binary.Decoder) error ```go type GlIsRenderbuffer struct { binary.Generate + Renderbuffer RenderbufferId Result bool } @@ -11799,10 +17913,7 @@ GlIsRenderbuffer #### func NewGlIsRenderbuffer ```go -func NewGlIsRenderbuffer( - pRenderbuffer RenderbufferId, - pResult bool, -) *GlIsRenderbuffer +func NewGlIsRenderbuffer(Renderbuffer RenderbufferId, Result bool) *GlIsRenderbuffer ``` #### func (*GlIsRenderbuffer) API @@ -11811,55 +17922,62 @@ func NewGlIsRenderbuffer( func (c *GlIsRenderbuffer) API() gfxapi.API ``` -#### func (*GlIsRenderbuffer) Class +#### func (*GlIsRenderbuffer) AddRead ```go -func (*GlIsRenderbuffer) Class() binary.Class +func (a *GlIsRenderbuffer) AddRead(rng memory.Range, id binary.ID) *GlIsRenderbuffer ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsRenderbuffer pointer is returned so that calls can be chained. -#### func (*GlIsRenderbuffer) Flags +#### func (*GlIsRenderbuffer) AddWrite ```go -func (c *GlIsRenderbuffer) Flags() atom.Flags +func (a *GlIsRenderbuffer) AddWrite(rng memory.Range, id binary.ID) *GlIsRenderbuffer ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsRenderbuffer pointer is returned so that calls can be chained. -#### func (*GlIsRenderbuffer) Mutate +#### func (*GlIsRenderbuffer) Class ```go -func (ϟa *GlIsRenderbuffer) Mutate(ϟs *gfxapi.State) error +func (*GlIsRenderbuffer) Class() binary.Class ``` -#### func (*GlIsRenderbuffer) Replay +#### func (*GlIsRenderbuffer) Flags ```go -func (ϟa *GlIsRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsRenderbuffer) Flags() atom.Flags ``` -#### func (*GlIsRenderbuffer) String +#### func (*GlIsRenderbuffer) Mutate ```go -func (c *GlIsRenderbuffer) String() string +func (ϟa *GlIsRenderbuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsRenderbuffer) TypeID +#### func (*GlIsRenderbuffer) Observations ```go -func (c *GlIsRenderbuffer) TypeID() atom.TypeID +func (a *GlIsRenderbuffer) Observations() *atom.Observations ``` -#### type GlIsRenderbuffer_Postback +#### func (*GlIsRenderbuffer) Replay ```go -type GlIsRenderbuffer_Postback struct { - Result bool -} +func (ϟa *GlIsRenderbuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsRenderbuffer) String + +```go +func (a *GlIsRenderbuffer) String() string +``` -#### func (*GlIsRenderbuffer_Postback) Decode +#### func (*GlIsRenderbuffer) TypeID ```go -func (o *GlIsRenderbuffer_Postback) Decode(d binary.Decoder) error +func (c *GlIsRenderbuffer) TypeID() atom.TypeID ``` #### type GlIsShader @@ -11867,6 +17985,7 @@ func (o *GlIsRenderbuffer_Postback) Decode(d binary.Decoder) error ```go type GlIsShader struct { binary.Generate + Shader ShaderId Result bool } @@ -11879,10 +17998,7 @@ GlIsShader #### func NewGlIsShader ```go -func NewGlIsShader( - pShader ShaderId, - pResult bool, -) *GlIsShader +func NewGlIsShader(Shader ShaderId, Result bool) *GlIsShader ``` #### func (*GlIsShader) API @@ -11891,55 +18007,62 @@ func NewGlIsShader( func (c *GlIsShader) API() gfxapi.API ``` -#### func (*GlIsShader) Class +#### func (*GlIsShader) AddRead ```go -func (*GlIsShader) Class() binary.Class +func (a *GlIsShader) AddRead(rng memory.Range, id binary.ID) *GlIsShader ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsShader pointer is returned so that calls can be chained. -#### func (*GlIsShader) Flags +#### func (*GlIsShader) AddWrite ```go -func (c *GlIsShader) Flags() atom.Flags +func (a *GlIsShader) AddWrite(rng memory.Range, id binary.ID) *GlIsShader ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsShader pointer is returned so that calls can be chained. -#### func (*GlIsShader) Mutate +#### func (*GlIsShader) Class ```go -func (ϟa *GlIsShader) Mutate(ϟs *gfxapi.State) error +func (*GlIsShader) Class() binary.Class ``` -#### func (*GlIsShader) Replay +#### func (*GlIsShader) Flags ```go -func (ϟa *GlIsShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsShader) Flags() atom.Flags ``` -#### func (*GlIsShader) String +#### func (*GlIsShader) Mutate ```go -func (c *GlIsShader) String() string +func (ϟa *GlIsShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsShader) TypeID +#### func (*GlIsShader) Observations ```go -func (c *GlIsShader) TypeID() atom.TypeID +func (a *GlIsShader) Observations() *atom.Observations ``` -#### type GlIsShader_Postback +#### func (*GlIsShader) Replay ```go -type GlIsShader_Postback struct { - Result bool -} +func (ϟa *GlIsShader) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsShader) String -#### func (*GlIsShader_Postback) Decode +```go +func (a *GlIsShader) String() string +``` + +#### func (*GlIsShader) TypeID ```go -func (o *GlIsShader_Postback) Decode(d binary.Decoder) error +func (c *GlIsShader) TypeID() atom.TypeID ``` #### type GlIsTexture @@ -11947,6 +18070,7 @@ func (o *GlIsShader_Postback) Decode(d binary.Decoder) error ```go type GlIsTexture struct { binary.Generate + Texture TextureId Result bool } @@ -11959,10 +18083,7 @@ GlIsTexture #### func NewGlIsTexture ```go -func NewGlIsTexture( - pTexture TextureId, - pResult bool, -) *GlIsTexture +func NewGlIsTexture(Texture TextureId, Result bool) *GlIsTexture ``` #### func (*GlIsTexture) API @@ -11971,55 +18092,62 @@ func NewGlIsTexture( func (c *GlIsTexture) API() gfxapi.API ``` -#### func (*GlIsTexture) Class +#### func (*GlIsTexture) AddRead ```go -func (*GlIsTexture) Class() binary.Class +func (a *GlIsTexture) AddRead(rng memory.Range, id binary.ID) *GlIsTexture ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsTexture pointer is returned so that calls can be chained. -#### func (*GlIsTexture) Flags +#### func (*GlIsTexture) AddWrite ```go -func (c *GlIsTexture) Flags() atom.Flags +func (a *GlIsTexture) AddWrite(rng memory.Range, id binary.ID) *GlIsTexture ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsTexture pointer is returned so that calls can be chained. -#### func (*GlIsTexture) Mutate +#### func (*GlIsTexture) Class ```go -func (ϟa *GlIsTexture) Mutate(ϟs *gfxapi.State) error +func (*GlIsTexture) Class() binary.Class ``` -#### func (*GlIsTexture) Replay +#### func (*GlIsTexture) Flags ```go -func (ϟa *GlIsTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsTexture) Flags() atom.Flags ``` -#### func (*GlIsTexture) String +#### func (*GlIsTexture) Mutate ```go -func (c *GlIsTexture) String() string +func (ϟa *GlIsTexture) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsTexture) TypeID +#### func (*GlIsTexture) Observations ```go -func (c *GlIsTexture) TypeID() atom.TypeID +func (a *GlIsTexture) Observations() *atom.Observations ``` -#### type GlIsTexture_Postback +#### func (*GlIsTexture) Replay ```go -type GlIsTexture_Postback struct { - Result bool -} +func (ϟa *GlIsTexture) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsTexture) String + +```go +func (a *GlIsTexture) String() string +``` -#### func (*GlIsTexture_Postback) Decode +#### func (*GlIsTexture) TypeID ```go -func (o *GlIsTexture_Postback) Decode(d binary.Decoder) error +func (c *GlIsTexture) TypeID() atom.TypeID ``` #### type GlIsVertexArrayOES @@ -12027,6 +18155,7 @@ func (o *GlIsTexture_Postback) Decode(d binary.Decoder) error ```go type GlIsVertexArrayOES struct { binary.Generate + Array VertexArrayId Result bool } @@ -12039,10 +18168,7 @@ GlIsVertexArrayOES #### func NewGlIsVertexArrayOES ```go -func NewGlIsVertexArrayOES( - pArray VertexArrayId, - pResult bool, -) *GlIsVertexArrayOES +func NewGlIsVertexArrayOES(Array VertexArrayId, Result bool) *GlIsVertexArrayOES ``` #### func (*GlIsVertexArrayOES) API @@ -12051,55 +18177,64 @@ func NewGlIsVertexArrayOES( func (c *GlIsVertexArrayOES) API() gfxapi.API ``` -#### func (*GlIsVertexArrayOES) Class +#### func (*GlIsVertexArrayOES) AddRead ```go -func (*GlIsVertexArrayOES) Class() binary.Class +func (a *GlIsVertexArrayOES) AddRead(rng memory.Range, id binary.ID) *GlIsVertexArrayOES ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlIsVertexArrayOES pointer is returned so that calls can be +chained. -#### func (*GlIsVertexArrayOES) Flags +#### func (*GlIsVertexArrayOES) AddWrite ```go -func (c *GlIsVertexArrayOES) Flags() atom.Flags +func (a *GlIsVertexArrayOES) AddWrite(rng memory.Range, id binary.ID) *GlIsVertexArrayOES ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlIsVertexArrayOES pointer is returned so that calls can be +chained. -#### func (*GlIsVertexArrayOES) Mutate +#### func (*GlIsVertexArrayOES) Class ```go -func (ϟa *GlIsVertexArrayOES) Mutate(ϟs *gfxapi.State) error +func (*GlIsVertexArrayOES) Class() binary.Class ``` -#### func (*GlIsVertexArrayOES) Replay +#### func (*GlIsVertexArrayOES) Flags ```go -func (ϟa *GlIsVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlIsVertexArrayOES) Flags() atom.Flags ``` -#### func (*GlIsVertexArrayOES) String +#### func (*GlIsVertexArrayOES) Mutate ```go -func (c *GlIsVertexArrayOES) String() string +func (ϟa *GlIsVertexArrayOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlIsVertexArrayOES) TypeID +#### func (*GlIsVertexArrayOES) Observations ```go -func (c *GlIsVertexArrayOES) TypeID() atom.TypeID +func (a *GlIsVertexArrayOES) Observations() *atom.Observations ``` -#### type GlIsVertexArrayOES_Postback +#### func (*GlIsVertexArrayOES) Replay ```go -type GlIsVertexArrayOES_Postback struct { - Result bool -} +func (ϟa *GlIsVertexArrayOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlIsVertexArrayOES) String -#### func (*GlIsVertexArrayOES_Postback) Decode +```go +func (a *GlIsVertexArrayOES) String() string +``` + +#### func (*GlIsVertexArrayOES) TypeID ```go -func (o *GlIsVertexArrayOES_Postback) Decode(d binary.Decoder) error +func (c *GlIsVertexArrayOES) TypeID() atom.TypeID ``` #### type GlLineWidth @@ -12107,6 +18242,7 @@ func (o *GlIsVertexArrayOES_Postback) Decode(d binary.Decoder) error ```go type GlLineWidth struct { binary.Generate + Width float32 } ``` @@ -12118,9 +18254,7 @@ GlLineWidth #### func NewGlLineWidth ```go -func NewGlLineWidth( - pWidth float32, -) *GlLineWidth +func NewGlLineWidth(Width float32) *GlLineWidth ``` #### func (*GlLineWidth) API @@ -12129,6 +18263,22 @@ func NewGlLineWidth( func (c *GlLineWidth) API() gfxapi.API ``` +#### func (*GlLineWidth) AddRead + +```go +func (a *GlLineWidth) AddRead(rng memory.Range, id binary.ID) *GlLineWidth +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlLineWidth pointer is returned so that calls can be chained. + +#### func (*GlLineWidth) AddWrite + +```go +func (a *GlLineWidth) AddWrite(rng memory.Range, id binary.ID) *GlLineWidth +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlLineWidth pointer is returned so that calls can be chained. + #### func (*GlLineWidth) Class ```go @@ -12144,19 +18294,25 @@ func (c *GlLineWidth) Flags() atom.Flags #### func (*GlLineWidth) Mutate ```go -func (ϟa *GlLineWidth) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlLineWidth) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlLineWidth) Observations + +```go +func (a *GlLineWidth) Observations() *atom.Observations ``` #### func (*GlLineWidth) Replay ```go -func (ϟa *GlLineWidth) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlLineWidth) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlLineWidth) String ```go -func (c *GlLineWidth) String() string +func (a *GlLineWidth) String() string ``` #### func (*GlLineWidth) TypeID @@ -12170,6 +18326,7 @@ func (c *GlLineWidth) TypeID() atom.TypeID ```go type GlLinkProgram struct { binary.Generate + Program ProgramId } ``` @@ -12181,9 +18338,7 @@ GlLinkProgram #### func NewGlLinkProgram ```go -func NewGlLinkProgram( - pProgram ProgramId, -) *GlLinkProgram +func NewGlLinkProgram(Program ProgramId) *GlLinkProgram ``` #### func (*GlLinkProgram) API @@ -12192,6 +18347,22 @@ func NewGlLinkProgram( func (c *GlLinkProgram) API() gfxapi.API ``` +#### func (*GlLinkProgram) AddRead + +```go +func (a *GlLinkProgram) AddRead(rng memory.Range, id binary.ID) *GlLinkProgram +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlLinkProgram pointer is returned so that calls can be chained. + +#### func (*GlLinkProgram) AddWrite + +```go +func (a *GlLinkProgram) AddWrite(rng memory.Range, id binary.ID) *GlLinkProgram +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlLinkProgram pointer is returned so that calls can be chained. + #### func (*GlLinkProgram) Class ```go @@ -12207,19 +18378,25 @@ func (c *GlLinkProgram) Flags() atom.Flags #### func (*GlLinkProgram) Mutate ```go -func (ϟa *GlLinkProgram) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlLinkProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlLinkProgram) Observations + +```go +func (a *GlLinkProgram) Observations() *atom.Observations ``` #### func (*GlLinkProgram) Replay ```go -func (ϟa *GlLinkProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlLinkProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlLinkProgram) String ```go -func (c *GlLinkProgram) String() string +func (a *GlLinkProgram) String() string ``` #### func (*GlLinkProgram) TypeID @@ -12233,11 +18410,12 @@ func (c *GlLinkProgram) TypeID() atom.TypeID ```go type GlMapBufferRange struct { binary.Generate + Target BufferTarget Offset int32 Length int32 Access MapBufferRangeAccess - Result memory.Pointer + Result Voidᵖ } ``` @@ -12248,13 +18426,7 @@ GlMapBufferRange #### func NewGlMapBufferRange ```go -func NewGlMapBufferRange( - pTarget BufferTarget, - pOffset int32, - pLength int32, - pAccess MapBufferRangeAccess, - pResult memory.Pointer, -) *GlMapBufferRange +func NewGlMapBufferRange(Target BufferTarget, Offset int32, Length int32, Access MapBufferRangeAccess, Result memory.Pointer) *GlMapBufferRange ``` #### func (*GlMapBufferRange) API @@ -12263,55 +18435,62 @@ func NewGlMapBufferRange( func (c *GlMapBufferRange) API() gfxapi.API ``` -#### func (*GlMapBufferRange) Class +#### func (*GlMapBufferRange) AddRead ```go -func (*GlMapBufferRange) Class() binary.Class +func (a *GlMapBufferRange) AddRead(rng memory.Range, id binary.ID) *GlMapBufferRange ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlMapBufferRange pointer is returned so that calls can be chained. -#### func (*GlMapBufferRange) Flags +#### func (*GlMapBufferRange) AddWrite ```go -func (c *GlMapBufferRange) Flags() atom.Flags +func (a *GlMapBufferRange) AddWrite(rng memory.Range, id binary.ID) *GlMapBufferRange ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlMapBufferRange pointer is returned so that calls can be chained. -#### func (*GlMapBufferRange) Mutate +#### func (*GlMapBufferRange) Class ```go -func (ϟa *GlMapBufferRange) Mutate(ϟs *gfxapi.State) error +func (*GlMapBufferRange) Class() binary.Class ``` -#### func (*GlMapBufferRange) Replay +#### func (*GlMapBufferRange) Flags ```go -func (ϟa *GlMapBufferRange) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlMapBufferRange) Flags() atom.Flags ``` -#### func (*GlMapBufferRange) String +#### func (*GlMapBufferRange) Mutate ```go -func (c *GlMapBufferRange) String() string +func (ϟa *GlMapBufferRange) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlMapBufferRange) TypeID +#### func (*GlMapBufferRange) Observations ```go -func (c *GlMapBufferRange) TypeID() atom.TypeID +func (a *GlMapBufferRange) Observations() *atom.Observations ``` -#### type GlMapBufferRange_Postback +#### func (*GlMapBufferRange) Replay ```go -type GlMapBufferRange_Postback struct { - Result []byte -} +func (ϟa *GlMapBufferRange) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlMapBufferRange) String -#### func (*GlMapBufferRange_Postback) Decode +```go +func (a *GlMapBufferRange) String() string +``` + +#### func (*GlMapBufferRange) TypeID ```go -func (o *GlMapBufferRange_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *GlMapBufferRange) TypeID() atom.TypeID ``` #### type GlPixelStorei @@ -12319,6 +18498,7 @@ func (o *GlMapBufferRange_Postback) Decode(result_cnt uint64, d binary.Decoder) ```go type GlPixelStorei struct { binary.Generate + Parameter PixelStoreParameter Value int32 } @@ -12331,10 +18511,7 @@ GlPixelStorei #### func NewGlPixelStorei ```go -func NewGlPixelStorei( - pParameter PixelStoreParameter, - pValue int32, -) *GlPixelStorei +func NewGlPixelStorei(Parameter PixelStoreParameter, Value int32) *GlPixelStorei ``` #### func (*GlPixelStorei) API @@ -12343,6 +18520,22 @@ func NewGlPixelStorei( func (c *GlPixelStorei) API() gfxapi.API ``` +#### func (*GlPixelStorei) AddRead + +```go +func (a *GlPixelStorei) AddRead(rng memory.Range, id binary.ID) *GlPixelStorei +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlPixelStorei pointer is returned so that calls can be chained. + +#### func (*GlPixelStorei) AddWrite + +```go +func (a *GlPixelStorei) AddWrite(rng memory.Range, id binary.ID) *GlPixelStorei +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlPixelStorei pointer is returned so that calls can be chained. + #### func (*GlPixelStorei) Class ```go @@ -12358,19 +18551,25 @@ func (c *GlPixelStorei) Flags() atom.Flags #### func (*GlPixelStorei) Mutate ```go -func (ϟa *GlPixelStorei) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlPixelStorei) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlPixelStorei) Observations + +```go +func (a *GlPixelStorei) Observations() *atom.Observations ``` #### func (*GlPixelStorei) Replay ```go -func (ϟa *GlPixelStorei) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlPixelStorei) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlPixelStorei) String ```go -func (c *GlPixelStorei) String() string +func (a *GlPixelStorei) String() string ``` #### func (*GlPixelStorei) TypeID @@ -12384,6 +18583,7 @@ func (c *GlPixelStorei) TypeID() atom.TypeID ```go type GlPolygonOffset struct { binary.Generate + ScaleFactor float32 Units float32 } @@ -12396,10 +18596,7 @@ GlPolygonOffset #### func NewGlPolygonOffset ```go -func NewGlPolygonOffset( - pScaleFactor float32, - pUnits float32, -) *GlPolygonOffset +func NewGlPolygonOffset(Scale_factor float32, Units float32) *GlPolygonOffset ``` #### func (*GlPolygonOffset) API @@ -12408,6 +18605,22 @@ func NewGlPolygonOffset( func (c *GlPolygonOffset) API() gfxapi.API ``` +#### func (*GlPolygonOffset) AddRead + +```go +func (a *GlPolygonOffset) AddRead(rng memory.Range, id binary.ID) *GlPolygonOffset +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlPolygonOffset pointer is returned so that calls can be chained. + +#### func (*GlPolygonOffset) AddWrite + +```go +func (a *GlPolygonOffset) AddWrite(rng memory.Range, id binary.ID) *GlPolygonOffset +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlPolygonOffset pointer is returned so that calls can be chained. + #### func (*GlPolygonOffset) Class ```go @@ -12423,19 +18636,25 @@ func (c *GlPolygonOffset) Flags() atom.Flags #### func (*GlPolygonOffset) Mutate ```go -func (ϟa *GlPolygonOffset) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlPolygonOffset) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlPolygonOffset) Observations + +```go +func (a *GlPolygonOffset) Observations() *atom.Observations ``` #### func (*GlPolygonOffset) Replay ```go -func (ϟa *GlPolygonOffset) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlPolygonOffset) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlPolygonOffset) String ```go -func (c *GlPolygonOffset) String() string +func (a *GlPolygonOffset) String() string ``` #### func (*GlPolygonOffset) TypeID @@ -12468,6 +18687,24 @@ func NewGlPopGroupMarkerEXT() *GlPopGroupMarkerEXT func (c *GlPopGroupMarkerEXT) API() gfxapi.API ``` +#### func (*GlPopGroupMarkerEXT) AddRead + +```go +func (a *GlPopGroupMarkerEXT) AddRead(rng memory.Range, id binary.ID) *GlPopGroupMarkerEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlPopGroupMarkerEXT pointer is returned so that calls can be +chained. + +#### func (*GlPopGroupMarkerEXT) AddWrite + +```go +func (a *GlPopGroupMarkerEXT) AddWrite(rng memory.Range, id binary.ID) *GlPopGroupMarkerEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlPopGroupMarkerEXT pointer is returned so that calls can be +chained. + #### func (*GlPopGroupMarkerEXT) Class ```go @@ -12483,19 +18720,25 @@ func (c *GlPopGroupMarkerEXT) Flags() atom.Flags #### func (*GlPopGroupMarkerEXT) Mutate ```go -func (ϟa *GlPopGroupMarkerEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlPopGroupMarkerEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlPopGroupMarkerEXT) Observations + +```go +func (a *GlPopGroupMarkerEXT) Observations() *atom.Observations ``` #### func (*GlPopGroupMarkerEXT) Replay ```go -func (ϟa *GlPopGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlPopGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlPopGroupMarkerEXT) String ```go -func (c *GlPopGroupMarkerEXT) String() string +func (a *GlPopGroupMarkerEXT) String() string ``` #### func (*GlPopGroupMarkerEXT) TypeID @@ -12509,9 +18752,10 @@ func (c *GlPopGroupMarkerEXT) TypeID() atom.TypeID ```go type GlProgramBinaryOES struct { binary.Generate + Program ProgramId BinaryFormat uint32 - Binary memory.Pointer + Binary Voidᵖ BinarySize int32 } ``` @@ -12523,12 +18767,7 @@ GlProgramBinaryOES #### func NewGlProgramBinaryOES ```go -func NewGlProgramBinaryOES( - pProgram ProgramId, - pBinaryFormat uint32, - pBinary memory.Pointer, - pBinarySize int32, -) *GlProgramBinaryOES +func NewGlProgramBinaryOES(Program ProgramId, Binary_format uint32, Binary memory.Pointer, Binary_size int32) *GlProgramBinaryOES ``` #### func (*GlProgramBinaryOES) API @@ -12537,6 +18776,24 @@ func NewGlProgramBinaryOES( func (c *GlProgramBinaryOES) API() gfxapi.API ``` +#### func (*GlProgramBinaryOES) AddRead + +```go +func (a *GlProgramBinaryOES) AddRead(rng memory.Range, id binary.ID) *GlProgramBinaryOES +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlProgramBinaryOES pointer is returned so that calls can be +chained. + +#### func (*GlProgramBinaryOES) AddWrite + +```go +func (a *GlProgramBinaryOES) AddWrite(rng memory.Range, id binary.ID) *GlProgramBinaryOES +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlProgramBinaryOES pointer is returned so that calls can be +chained. + #### func (*GlProgramBinaryOES) Class ```go @@ -12552,19 +18809,25 @@ func (c *GlProgramBinaryOES) Flags() atom.Flags #### func (*GlProgramBinaryOES) Mutate ```go -func (ϟa *GlProgramBinaryOES) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlProgramBinaryOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlProgramBinaryOES) Observations + +```go +func (a *GlProgramBinaryOES) Observations() *atom.Observations ``` #### func (*GlProgramBinaryOES) Replay ```go -func (ϟa *GlProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlProgramBinaryOES) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlProgramBinaryOES) String ```go -func (c *GlProgramBinaryOES) String() string +func (a *GlProgramBinaryOES) String() string ``` #### func (*GlProgramBinaryOES) TypeID @@ -12578,8 +18841,9 @@ func (c *GlProgramBinaryOES) TypeID() atom.TypeID ```go type GlPushGroupMarkerEXT struct { binary.Generate + Length int32 - Marker string + Marker Charᵖ } ``` @@ -12590,10 +18854,7 @@ GlPushGroupMarkerEXT #### func NewGlPushGroupMarkerEXT ```go -func NewGlPushGroupMarkerEXT( - pLength int32, - pMarker string, -) *GlPushGroupMarkerEXT +func NewGlPushGroupMarkerEXT(Length int32, Marker memory.Pointer) *GlPushGroupMarkerEXT ``` #### func (*GlPushGroupMarkerEXT) API @@ -12602,6 +18863,24 @@ func NewGlPushGroupMarkerEXT( func (c *GlPushGroupMarkerEXT) API() gfxapi.API ``` +#### func (*GlPushGroupMarkerEXT) AddRead + +```go +func (a *GlPushGroupMarkerEXT) AddRead(rng memory.Range, id binary.ID) *GlPushGroupMarkerEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlPushGroupMarkerEXT pointer is returned so that calls can be +chained. + +#### func (*GlPushGroupMarkerEXT) AddWrite + +```go +func (a *GlPushGroupMarkerEXT) AddWrite(rng memory.Range, id binary.ID) *GlPushGroupMarkerEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlPushGroupMarkerEXT pointer is returned so that calls can be +chained. + #### func (*GlPushGroupMarkerEXT) Class ```go @@ -12617,19 +18896,25 @@ func (c *GlPushGroupMarkerEXT) Flags() atom.Flags #### func (*GlPushGroupMarkerEXT) Mutate ```go -func (ϟa *GlPushGroupMarkerEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlPushGroupMarkerEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlPushGroupMarkerEXT) Observations + +```go +func (a *GlPushGroupMarkerEXT) Observations() *atom.Observations ``` #### func (*GlPushGroupMarkerEXT) Replay ```go -func (ϟa *GlPushGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlPushGroupMarkerEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlPushGroupMarkerEXT) String ```go -func (c *GlPushGroupMarkerEXT) String() string +func (a *GlPushGroupMarkerEXT) String() string ``` #### func (*GlPushGroupMarkerEXT) TypeID @@ -12643,6 +18928,7 @@ func (c *GlPushGroupMarkerEXT) TypeID() atom.TypeID ```go type GlQueryCounterEXT struct { binary.Generate + Query QueryId Target QueryTarget } @@ -12655,10 +18941,7 @@ GlQueryCounterEXT #### func NewGlQueryCounterEXT ```go -func NewGlQueryCounterEXT( - pQuery QueryId, - pTarget QueryTarget, -) *GlQueryCounterEXT +func NewGlQueryCounterEXT(Query QueryId, Target QueryTarget) *GlQueryCounterEXT ``` #### func (*GlQueryCounterEXT) API @@ -12667,6 +18950,22 @@ func NewGlQueryCounterEXT( func (c *GlQueryCounterEXT) API() gfxapi.API ``` +#### func (*GlQueryCounterEXT) AddRead + +```go +func (a *GlQueryCounterEXT) AddRead(rng memory.Range, id binary.ID) *GlQueryCounterEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlQueryCounterEXT pointer is returned so that calls can be chained. + +#### func (*GlQueryCounterEXT) AddWrite + +```go +func (a *GlQueryCounterEXT) AddWrite(rng memory.Range, id binary.ID) *GlQueryCounterEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlQueryCounterEXT pointer is returned so that calls can be chained. + #### func (*GlQueryCounterEXT) Class ```go @@ -12682,19 +18981,25 @@ func (c *GlQueryCounterEXT) Flags() atom.Flags #### func (*GlQueryCounterEXT) Mutate ```go -func (ϟa *GlQueryCounterEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlQueryCounterEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlQueryCounterEXT) Observations + +```go +func (a *GlQueryCounterEXT) Observations() *atom.Observations ``` #### func (*GlQueryCounterEXT) Replay ```go -func (ϟa *GlQueryCounterEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlQueryCounterEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlQueryCounterEXT) String ```go -func (c *GlQueryCounterEXT) String() string +func (a *GlQueryCounterEXT) String() string ``` #### func (*GlQueryCounterEXT) TypeID @@ -12708,13 +19013,14 @@ func (c *GlQueryCounterEXT) TypeID() atom.TypeID ```go type GlReadPixels struct { binary.Generate + X int32 Y int32 Width int32 Height int32 Format BaseTexelFormat Type TexelType - Data memory.Pointer + Data Voidᵖ } ``` @@ -12725,15 +19031,7 @@ GlReadPixels #### func NewGlReadPixels ```go -func NewGlReadPixels( - pX int32, - pY int32, - pWidth int32, - pHeight int32, - pFormat BaseTexelFormat, - pType TexelType, - pData memory.Pointer, -) *GlReadPixels +func NewGlReadPixels(X int32, Y int32, Width int32, Height int32, Format BaseTexelFormat, Type TexelType, Data memory.Pointer) *GlReadPixels ``` #### func (*GlReadPixels) API @@ -12742,55 +19040,62 @@ func NewGlReadPixels( func (c *GlReadPixels) API() gfxapi.API ``` -#### func (*GlReadPixels) Class +#### func (*GlReadPixels) AddRead ```go -func (*GlReadPixels) Class() binary.Class +func (a *GlReadPixels) AddRead(rng memory.Range, id binary.ID) *GlReadPixels ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlReadPixels pointer is returned so that calls can be chained. -#### func (*GlReadPixels) Flags +#### func (*GlReadPixels) AddWrite ```go -func (c *GlReadPixels) Flags() atom.Flags +func (a *GlReadPixels) AddWrite(rng memory.Range, id binary.ID) *GlReadPixels ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlReadPixels pointer is returned so that calls can be chained. -#### func (*GlReadPixels) Mutate +#### func (*GlReadPixels) Class ```go -func (ϟa *GlReadPixels) Mutate(ϟs *gfxapi.State) error +func (*GlReadPixels) Class() binary.Class ``` -#### func (*GlReadPixels) Replay +#### func (*GlReadPixels) Flags ```go -func (ϟa *GlReadPixels) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *GlReadPixels) Flags() atom.Flags ``` -#### func (*GlReadPixels) String +#### func (*GlReadPixels) Mutate ```go -func (c *GlReadPixels) String() string +func (ϟa *GlReadPixels) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlReadPixels) TypeID +#### func (*GlReadPixels) Observations ```go -func (c *GlReadPixels) TypeID() atom.TypeID +func (a *GlReadPixels) Observations() *atom.Observations ``` -#### type GlReadPixels_Postback +#### func (*GlReadPixels) Replay ```go -type GlReadPixels_Postback struct { - Data []byte -} +func (ϟa *GlReadPixels) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*GlReadPixels) String + +```go +func (a *GlReadPixels) String() string +``` -#### func (*GlReadPixels_Postback) Decode +#### func (*GlReadPixels) TypeID ```go -func (o *GlReadPixels_Postback) Decode(data_cnt uint64, d binary.Decoder) error +func (c *GlReadPixels) TypeID() atom.TypeID ``` #### type GlReleaseShaderCompiler @@ -12817,6 +19122,24 @@ func NewGlReleaseShaderCompiler() *GlReleaseShaderCompiler func (c *GlReleaseShaderCompiler) API() gfxapi.API ``` +#### func (*GlReleaseShaderCompiler) AddRead + +```go +func (a *GlReleaseShaderCompiler) AddRead(rng memory.Range, id binary.ID) *GlReleaseShaderCompiler +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlReleaseShaderCompiler pointer is returned so that calls can be +chained. + +#### func (*GlReleaseShaderCompiler) AddWrite + +```go +func (a *GlReleaseShaderCompiler) AddWrite(rng memory.Range, id binary.ID) *GlReleaseShaderCompiler +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlReleaseShaderCompiler pointer is returned so that calls can be +chained. + #### func (*GlReleaseShaderCompiler) Class ```go @@ -12832,19 +19155,25 @@ func (c *GlReleaseShaderCompiler) Flags() atom.Flags #### func (*GlReleaseShaderCompiler) Mutate ```go -func (ϟa *GlReleaseShaderCompiler) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlReleaseShaderCompiler) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlReleaseShaderCompiler) Observations + +```go +func (a *GlReleaseShaderCompiler) Observations() *atom.Observations ``` #### func (*GlReleaseShaderCompiler) Replay ```go -func (ϟa *GlReleaseShaderCompiler) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlReleaseShaderCompiler) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlReleaseShaderCompiler) String ```go -func (c *GlReleaseShaderCompiler) String() string +func (a *GlReleaseShaderCompiler) String() string ``` #### func (*GlReleaseShaderCompiler) TypeID @@ -12858,6 +19187,7 @@ func (c *GlReleaseShaderCompiler) TypeID() atom.TypeID ```go type GlRenderbufferStorage struct { binary.Generate + Target RenderbufferTarget Format RenderbufferFormat Width int32 @@ -12872,12 +19202,7 @@ GlRenderbufferStorage #### func NewGlRenderbufferStorage ```go -func NewGlRenderbufferStorage( - pTarget RenderbufferTarget, - pFormat RenderbufferFormat, - pWidth int32, - pHeight int32, -) *GlRenderbufferStorage +func NewGlRenderbufferStorage(Target RenderbufferTarget, Format RenderbufferFormat, Width int32, Height int32) *GlRenderbufferStorage ``` #### func (*GlRenderbufferStorage) API @@ -12886,6 +19211,24 @@ func NewGlRenderbufferStorage( func (c *GlRenderbufferStorage) API() gfxapi.API ``` +#### func (*GlRenderbufferStorage) AddRead + +```go +func (a *GlRenderbufferStorage) AddRead(rng memory.Range, id binary.ID) *GlRenderbufferStorage +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlRenderbufferStorage pointer is returned so that calls can be +chained. + +#### func (*GlRenderbufferStorage) AddWrite + +```go +func (a *GlRenderbufferStorage) AddWrite(rng memory.Range, id binary.ID) *GlRenderbufferStorage +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlRenderbufferStorage pointer is returned so that calls can be +chained. + #### func (*GlRenderbufferStorage) Class ```go @@ -12901,19 +19244,25 @@ func (c *GlRenderbufferStorage) Flags() atom.Flags #### func (*GlRenderbufferStorage) Mutate ```go -func (ϟa *GlRenderbufferStorage) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlRenderbufferStorage) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlRenderbufferStorage) Observations + +```go +func (a *GlRenderbufferStorage) Observations() *atom.Observations ``` #### func (*GlRenderbufferStorage) Replay ```go -func (ϟa *GlRenderbufferStorage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlRenderbufferStorage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlRenderbufferStorage) String ```go -func (c *GlRenderbufferStorage) String() string +func (a *GlRenderbufferStorage) String() string ``` #### func (*GlRenderbufferStorage) TypeID @@ -12927,6 +19276,7 @@ func (c *GlRenderbufferStorage) TypeID() atom.TypeID ```go type GlRenderbufferStorageMultisample struct { binary.Generate + Target RenderbufferTarget Samples int32 Format RenderbufferFormat @@ -12942,13 +19292,7 @@ GlRenderbufferStorageMultisample #### func NewGlRenderbufferStorageMultisample ```go -func NewGlRenderbufferStorageMultisample( - pTarget RenderbufferTarget, - pSamples int32, - pFormat RenderbufferFormat, - pWidth int32, - pHeight int32, -) *GlRenderbufferStorageMultisample +func NewGlRenderbufferStorageMultisample(Target RenderbufferTarget, Samples int32, Format RenderbufferFormat, Width int32, Height int32) *GlRenderbufferStorageMultisample ``` #### func (*GlRenderbufferStorageMultisample) API @@ -12957,6 +19301,24 @@ func NewGlRenderbufferStorageMultisample( func (c *GlRenderbufferStorageMultisample) API() gfxapi.API ``` +#### func (*GlRenderbufferStorageMultisample) AddRead + +```go +func (a *GlRenderbufferStorageMultisample) AddRead(rng memory.Range, id binary.ID) *GlRenderbufferStorageMultisample +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlRenderbufferStorageMultisample pointer is returned so that calls +can be chained. + +#### func (*GlRenderbufferStorageMultisample) AddWrite + +```go +func (a *GlRenderbufferStorageMultisample) AddWrite(rng memory.Range, id binary.ID) *GlRenderbufferStorageMultisample +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlRenderbufferStorageMultisample pointer is returned so that calls +can be chained. + #### func (*GlRenderbufferStorageMultisample) Class ```go @@ -12972,19 +19334,25 @@ func (c *GlRenderbufferStorageMultisample) Flags() atom.Flags #### func (*GlRenderbufferStorageMultisample) Mutate ```go -func (ϟa *GlRenderbufferStorageMultisample) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlRenderbufferStorageMultisample) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlRenderbufferStorageMultisample) Observations + +```go +func (a *GlRenderbufferStorageMultisample) Observations() *atom.Observations ``` #### func (*GlRenderbufferStorageMultisample) Replay ```go -func (ϟa *GlRenderbufferStorageMultisample) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlRenderbufferStorageMultisample) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlRenderbufferStorageMultisample) String ```go -func (c *GlRenderbufferStorageMultisample) String() string +func (a *GlRenderbufferStorageMultisample) String() string ``` #### func (*GlRenderbufferStorageMultisample) TypeID @@ -12998,6 +19366,7 @@ func (c *GlRenderbufferStorageMultisample) TypeID() atom.TypeID ```go type GlSampleCoverage struct { binary.Generate + Value float32 Invert bool } @@ -13010,10 +19379,7 @@ GlSampleCoverage #### func NewGlSampleCoverage ```go -func NewGlSampleCoverage( - pValue float32, - pInvert bool, -) *GlSampleCoverage +func NewGlSampleCoverage(Value float32, Invert bool) *GlSampleCoverage ``` #### func (*GlSampleCoverage) API @@ -13022,6 +19388,22 @@ func NewGlSampleCoverage( func (c *GlSampleCoverage) API() gfxapi.API ``` +#### func (*GlSampleCoverage) AddRead + +```go +func (a *GlSampleCoverage) AddRead(rng memory.Range, id binary.ID) *GlSampleCoverage +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlSampleCoverage pointer is returned so that calls can be chained. + +#### func (*GlSampleCoverage) AddWrite + +```go +func (a *GlSampleCoverage) AddWrite(rng memory.Range, id binary.ID) *GlSampleCoverage +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlSampleCoverage pointer is returned so that calls can be chained. + #### func (*GlSampleCoverage) Class ```go @@ -13037,19 +19419,25 @@ func (c *GlSampleCoverage) Flags() atom.Flags #### func (*GlSampleCoverage) Mutate ```go -func (ϟa *GlSampleCoverage) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlSampleCoverage) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlSampleCoverage) Observations + +```go +func (a *GlSampleCoverage) Observations() *atom.Observations ``` #### func (*GlSampleCoverage) Replay ```go -func (ϟa *GlSampleCoverage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlSampleCoverage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlSampleCoverage) String ```go -func (c *GlSampleCoverage) String() string +func (a *GlSampleCoverage) String() string ``` #### func (*GlSampleCoverage) TypeID @@ -13063,6 +19451,7 @@ func (c *GlSampleCoverage) TypeID() atom.TypeID ```go type GlScissor struct { binary.Generate + X int32 Y int32 Width int32 @@ -13077,12 +19466,7 @@ GlScissor #### func NewGlScissor ```go -func NewGlScissor( - pX int32, - pY int32, - pWidth int32, - pHeight int32, -) *GlScissor +func NewGlScissor(X int32, Y int32, Width int32, Height int32) *GlScissor ``` #### func (*GlScissor) API @@ -13091,6 +19475,22 @@ func NewGlScissor( func (c *GlScissor) API() gfxapi.API ``` +#### func (*GlScissor) AddRead + +```go +func (a *GlScissor) AddRead(rng memory.Range, id binary.ID) *GlScissor +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlScissor pointer is returned so that calls can be chained. + +#### func (*GlScissor) AddWrite + +```go +func (a *GlScissor) AddWrite(rng memory.Range, id binary.ID) *GlScissor +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlScissor pointer is returned so that calls can be chained. + #### func (*GlScissor) Class ```go @@ -13106,19 +19506,25 @@ func (c *GlScissor) Flags() atom.Flags #### func (*GlScissor) Mutate ```go -func (ϟa *GlScissor) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlScissor) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlScissor) Observations + +```go +func (a *GlScissor) Observations() *atom.Observations ``` #### func (*GlScissor) Replay ```go -func (ϟa *GlScissor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlScissor) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlScissor) String ```go -func (c *GlScissor) String() string +func (a *GlScissor) String() string ``` #### func (*GlScissor) TypeID @@ -13132,10 +19538,11 @@ func (c *GlScissor) TypeID() atom.TypeID ```go type GlShaderBinary struct { binary.Generate + Count int32 - Shaders ShaderIdArray + Shaders ShaderIdᵖ BinaryFormat uint32 - Binary memory.Pointer + Binary Voidᵖ BinarySize int32 } ``` @@ -13147,13 +19554,7 @@ GlShaderBinary #### func NewGlShaderBinary ```go -func NewGlShaderBinary( - pCount int32, - pShaders ShaderIdArray, - pBinaryFormat uint32, - pBinary memory.Pointer, - pBinarySize int32, -) *GlShaderBinary +func NewGlShaderBinary(Count int32, Shaders memory.Pointer, Binary_format uint32, Binary memory.Pointer, Binary_size int32) *GlShaderBinary ``` #### func (*GlShaderBinary) API @@ -13162,6 +19563,22 @@ func NewGlShaderBinary( func (c *GlShaderBinary) API() gfxapi.API ``` +#### func (*GlShaderBinary) AddRead + +```go +func (a *GlShaderBinary) AddRead(rng memory.Range, id binary.ID) *GlShaderBinary +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlShaderBinary pointer is returned so that calls can be chained. + +#### func (*GlShaderBinary) AddWrite + +```go +func (a *GlShaderBinary) AddWrite(rng memory.Range, id binary.ID) *GlShaderBinary +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlShaderBinary pointer is returned so that calls can be chained. + #### func (*GlShaderBinary) Class ```go @@ -13177,19 +19594,25 @@ func (c *GlShaderBinary) Flags() atom.Flags #### func (*GlShaderBinary) Mutate ```go -func (ϟa *GlShaderBinary) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlShaderBinary) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlShaderBinary) Observations + +```go +func (a *GlShaderBinary) Observations() *atom.Observations ``` #### func (*GlShaderBinary) Replay ```go -func (ϟa *GlShaderBinary) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlShaderBinary) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlShaderBinary) String ```go -func (c *GlShaderBinary) String() string +func (a *GlShaderBinary) String() string ``` #### func (*GlShaderBinary) TypeID @@ -13203,10 +19626,11 @@ func (c *GlShaderBinary) TypeID() atom.TypeID ```go type GlShaderSource struct { binary.Generate + Shader ShaderId Count int32 - Source StringArray - Length S32Array + Source Charᵖᵖ + Length S32ᵖ } ``` @@ -13217,12 +19641,7 @@ GlShaderSource #### func NewGlShaderSource ```go -func NewGlShaderSource( - pShader ShaderId, - pCount int32, - pSource StringArray, - pLength S32Array, -) *GlShaderSource +func NewGlShaderSource(Shader ShaderId, Count int32, Source memory.Pointer, Length memory.Pointer) *GlShaderSource ``` #### func (*GlShaderSource) API @@ -13231,6 +19650,22 @@ func NewGlShaderSource( func (c *GlShaderSource) API() gfxapi.API ``` +#### func (*GlShaderSource) AddRead + +```go +func (a *GlShaderSource) AddRead(rng memory.Range, id binary.ID) *GlShaderSource +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlShaderSource pointer is returned so that calls can be chained. + +#### func (*GlShaderSource) AddWrite + +```go +func (a *GlShaderSource) AddWrite(rng memory.Range, id binary.ID) *GlShaderSource +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlShaderSource pointer is returned so that calls can be chained. + #### func (*GlShaderSource) Class ```go @@ -13246,19 +19681,25 @@ func (c *GlShaderSource) Flags() atom.Flags #### func (*GlShaderSource) Mutate ```go -func (ϟa *GlShaderSource) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlShaderSource) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlShaderSource) Observations + +```go +func (a *GlShaderSource) Observations() *atom.Observations ``` #### func (*GlShaderSource) Replay ```go -func (ϟa *GlShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlShaderSource) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlShaderSource) String ```go -func (c *GlShaderSource) String() string +func (a *GlShaderSource) String() string ``` #### func (*GlShaderSource) TypeID @@ -13272,6 +19713,7 @@ func (c *GlShaderSource) TypeID() atom.TypeID ```go type GlStartTilingQCOM struct { binary.Generate + X int32 Y int32 Width int32 @@ -13287,13 +19729,7 @@ GlStartTilingQCOM #### func NewGlStartTilingQCOM ```go -func NewGlStartTilingQCOM( - pX int32, - pY int32, - pWidth int32, - pHeight int32, - pPreserveMask TilePreserveMaskQCOM, -) *GlStartTilingQCOM +func NewGlStartTilingQCOM(X int32, Y int32, Width int32, Height int32, PreserveMask TilePreserveMaskQCOM) *GlStartTilingQCOM ``` #### func (*GlStartTilingQCOM) API @@ -13302,6 +19738,22 @@ func NewGlStartTilingQCOM( func (c *GlStartTilingQCOM) API() gfxapi.API ``` +#### func (*GlStartTilingQCOM) AddRead + +```go +func (a *GlStartTilingQCOM) AddRead(rng memory.Range, id binary.ID) *GlStartTilingQCOM +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlStartTilingQCOM pointer is returned so that calls can be chained. + +#### func (*GlStartTilingQCOM) AddWrite + +```go +func (a *GlStartTilingQCOM) AddWrite(rng memory.Range, id binary.ID) *GlStartTilingQCOM +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlStartTilingQCOM pointer is returned so that calls can be chained. + #### func (*GlStartTilingQCOM) Class ```go @@ -13317,19 +19769,25 @@ func (c *GlStartTilingQCOM) Flags() atom.Flags #### func (*GlStartTilingQCOM) Mutate ```go -func (ϟa *GlStartTilingQCOM) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlStartTilingQCOM) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlStartTilingQCOM) Observations + +```go +func (a *GlStartTilingQCOM) Observations() *atom.Observations ``` #### func (*GlStartTilingQCOM) Replay ```go -func (ϟa *GlStartTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlStartTilingQCOM) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlStartTilingQCOM) String ```go -func (c *GlStartTilingQCOM) String() string +func (a *GlStartTilingQCOM) String() string ``` #### func (*GlStartTilingQCOM) TypeID @@ -13343,6 +19801,7 @@ func (c *GlStartTilingQCOM) TypeID() atom.TypeID ```go type GlStencilFuncSeparate struct { binary.Generate + Face FaceMode Function TestFunction ReferenceValue int32 @@ -13357,12 +19816,7 @@ GlStencilFuncSeparate #### func NewGlStencilFuncSeparate ```go -func NewGlStencilFuncSeparate( - pFace FaceMode, - pFunction TestFunction, - pReferenceValue int32, - pMask int32, -) *GlStencilFuncSeparate +func NewGlStencilFuncSeparate(Face FaceMode, Function TestFunction, Reference_value int32, Mask int32) *GlStencilFuncSeparate ``` #### func (*GlStencilFuncSeparate) API @@ -13371,6 +19825,24 @@ func NewGlStencilFuncSeparate( func (c *GlStencilFuncSeparate) API() gfxapi.API ``` +#### func (*GlStencilFuncSeparate) AddRead + +```go +func (a *GlStencilFuncSeparate) AddRead(rng memory.Range, id binary.ID) *GlStencilFuncSeparate +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlStencilFuncSeparate pointer is returned so that calls can be +chained. + +#### func (*GlStencilFuncSeparate) AddWrite + +```go +func (a *GlStencilFuncSeparate) AddWrite(rng memory.Range, id binary.ID) *GlStencilFuncSeparate +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlStencilFuncSeparate pointer is returned so that calls can be +chained. + #### func (*GlStencilFuncSeparate) Class ```go @@ -13386,19 +19858,25 @@ func (c *GlStencilFuncSeparate) Flags() atom.Flags #### func (*GlStencilFuncSeparate) Mutate ```go -func (ϟa *GlStencilFuncSeparate) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlStencilFuncSeparate) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlStencilFuncSeparate) Observations + +```go +func (a *GlStencilFuncSeparate) Observations() *atom.Observations ``` #### func (*GlStencilFuncSeparate) Replay ```go -func (ϟa *GlStencilFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlStencilFuncSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlStencilFuncSeparate) String ```go -func (c *GlStencilFuncSeparate) String() string +func (a *GlStencilFuncSeparate) String() string ``` #### func (*GlStencilFuncSeparate) TypeID @@ -13412,6 +19890,7 @@ func (c *GlStencilFuncSeparate) TypeID() atom.TypeID ```go type GlStencilMask struct { binary.Generate + Mask uint32 } ``` @@ -13423,9 +19902,7 @@ GlStencilMask #### func NewGlStencilMask ```go -func NewGlStencilMask( - pMask uint32, -) *GlStencilMask +func NewGlStencilMask(Mask uint32) *GlStencilMask ``` #### func (*GlStencilMask) API @@ -13434,6 +19911,22 @@ func NewGlStencilMask( func (c *GlStencilMask) API() gfxapi.API ``` +#### func (*GlStencilMask) AddRead + +```go +func (a *GlStencilMask) AddRead(rng memory.Range, id binary.ID) *GlStencilMask +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlStencilMask pointer is returned so that calls can be chained. + +#### func (*GlStencilMask) AddWrite + +```go +func (a *GlStencilMask) AddWrite(rng memory.Range, id binary.ID) *GlStencilMask +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlStencilMask pointer is returned so that calls can be chained. + #### func (*GlStencilMask) Class ```go @@ -13449,19 +19942,25 @@ func (c *GlStencilMask) Flags() atom.Flags #### func (*GlStencilMask) Mutate ```go -func (ϟa *GlStencilMask) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlStencilMask) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlStencilMask) Observations + +```go +func (a *GlStencilMask) Observations() *atom.Observations ``` #### func (*GlStencilMask) Replay ```go -func (ϟa *GlStencilMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlStencilMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlStencilMask) String ```go -func (c *GlStencilMask) String() string +func (a *GlStencilMask) String() string ``` #### func (*GlStencilMask) TypeID @@ -13475,6 +19974,7 @@ func (c *GlStencilMask) TypeID() atom.TypeID ```go type GlStencilMaskSeparate struct { binary.Generate + Face FaceMode Mask uint32 } @@ -13487,10 +19987,7 @@ GlStencilMaskSeparate #### func NewGlStencilMaskSeparate ```go -func NewGlStencilMaskSeparate( - pFace FaceMode, - pMask uint32, -) *GlStencilMaskSeparate +func NewGlStencilMaskSeparate(Face FaceMode, Mask uint32) *GlStencilMaskSeparate ``` #### func (*GlStencilMaskSeparate) API @@ -13499,6 +19996,24 @@ func NewGlStencilMaskSeparate( func (c *GlStencilMaskSeparate) API() gfxapi.API ``` +#### func (*GlStencilMaskSeparate) AddRead + +```go +func (a *GlStencilMaskSeparate) AddRead(rng memory.Range, id binary.ID) *GlStencilMaskSeparate +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlStencilMaskSeparate pointer is returned so that calls can be +chained. + +#### func (*GlStencilMaskSeparate) AddWrite + +```go +func (a *GlStencilMaskSeparate) AddWrite(rng memory.Range, id binary.ID) *GlStencilMaskSeparate +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlStencilMaskSeparate pointer is returned so that calls can be +chained. + #### func (*GlStencilMaskSeparate) Class ```go @@ -13514,19 +20029,25 @@ func (c *GlStencilMaskSeparate) Flags() atom.Flags #### func (*GlStencilMaskSeparate) Mutate ```go -func (ϟa *GlStencilMaskSeparate) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlStencilMaskSeparate) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlStencilMaskSeparate) Observations + +```go +func (a *GlStencilMaskSeparate) Observations() *atom.Observations ``` #### func (*GlStencilMaskSeparate) Replay ```go -func (ϟa *GlStencilMaskSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlStencilMaskSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlStencilMaskSeparate) String ```go -func (c *GlStencilMaskSeparate) String() string +func (a *GlStencilMaskSeparate) String() string ``` #### func (*GlStencilMaskSeparate) TypeID @@ -13540,6 +20061,7 @@ func (c *GlStencilMaskSeparate) TypeID() atom.TypeID ```go type GlStencilOpSeparate struct { binary.Generate + Face FaceMode StencilFail StencilAction StencilPassDepthFail StencilAction @@ -13554,12 +20076,7 @@ GlStencilOpSeparate #### func NewGlStencilOpSeparate ```go -func NewGlStencilOpSeparate( - pFace FaceMode, - pStencilFail StencilAction, - pStencilPassDepthFail StencilAction, - pStencilPassDepthPass StencilAction, -) *GlStencilOpSeparate +func NewGlStencilOpSeparate(Face FaceMode, Stencil_fail StencilAction, Stencil_pass_depth_fail StencilAction, Stencil_pass_depth_pass StencilAction) *GlStencilOpSeparate ``` #### func (*GlStencilOpSeparate) API @@ -13568,6 +20085,24 @@ func NewGlStencilOpSeparate( func (c *GlStencilOpSeparate) API() gfxapi.API ``` +#### func (*GlStencilOpSeparate) AddRead + +```go +func (a *GlStencilOpSeparate) AddRead(rng memory.Range, id binary.ID) *GlStencilOpSeparate +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlStencilOpSeparate pointer is returned so that calls can be +chained. + +#### func (*GlStencilOpSeparate) AddWrite + +```go +func (a *GlStencilOpSeparate) AddWrite(rng memory.Range, id binary.ID) *GlStencilOpSeparate +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlStencilOpSeparate pointer is returned so that calls can be +chained. + #### func (*GlStencilOpSeparate) Class ```go @@ -13583,19 +20118,25 @@ func (c *GlStencilOpSeparate) Flags() atom.Flags #### func (*GlStencilOpSeparate) Mutate ```go -func (ϟa *GlStencilOpSeparate) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlStencilOpSeparate) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlStencilOpSeparate) Observations + +```go +func (a *GlStencilOpSeparate) Observations() *atom.Observations ``` #### func (*GlStencilOpSeparate) Replay ```go -func (ϟa *GlStencilOpSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlStencilOpSeparate) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlStencilOpSeparate) String ```go -func (c *GlStencilOpSeparate) String() string +func (a *GlStencilOpSeparate) String() string ``` #### func (*GlStencilOpSeparate) TypeID @@ -13609,6 +20150,7 @@ func (c *GlStencilOpSeparate) TypeID() atom.TypeID ```go type GlTexImage2D struct { binary.Generate + Target TextureImageTarget Level int32 InternalFormat TexelFormat @@ -13628,17 +20170,7 @@ GlTexImage2D #### func NewGlTexImage2D ```go -func NewGlTexImage2D( - pTarget TextureImageTarget, - pLevel int32, - pInternalFormat TexelFormat, - pWidth int32, - pHeight int32, - pBorder int32, - pFormat TexelFormat, - pType TexelType, - pData TexturePointer, -) *GlTexImage2D +func NewGlTexImage2D(Target TextureImageTarget, Level int32, Internal_format TexelFormat, Width int32, Height int32, Border int32, Format TexelFormat, Type TexelType, Data memory.Pointer) *GlTexImage2D ``` #### func (*GlTexImage2D) API @@ -13647,6 +20179,22 @@ func NewGlTexImage2D( func (c *GlTexImage2D) API() gfxapi.API ``` +#### func (*GlTexImage2D) AddRead + +```go +func (a *GlTexImage2D) AddRead(rng memory.Range, id binary.ID) *GlTexImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexImage2D pointer is returned so that calls can be chained. + +#### func (*GlTexImage2D) AddWrite + +```go +func (a *GlTexImage2D) AddWrite(rng memory.Range, id binary.ID) *GlTexImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexImage2D pointer is returned so that calls can be chained. + #### func (*GlTexImage2D) Class ```go @@ -13662,19 +20210,25 @@ func (c *GlTexImage2D) Flags() atom.Flags #### func (*GlTexImage2D) Mutate ```go -func (ϟa *GlTexImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexImage2D) Observations + +```go +func (a *GlTexImage2D) Observations() *atom.Observations ``` #### func (*GlTexImage2D) Replay ```go -func (ϟa *GlTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexImage2D) String ```go -func (c *GlTexImage2D) String() string +func (a *GlTexImage2D) String() string ``` #### func (*GlTexImage2D) TypeID @@ -13688,6 +20242,7 @@ func (c *GlTexImage2D) TypeID() atom.TypeID ```go type GlTexParameterf struct { binary.Generate + Target TextureTarget Parameter TextureParameter Value float32 @@ -13701,11 +20256,7 @@ GlTexParameterf #### func NewGlTexParameterf ```go -func NewGlTexParameterf( - pTarget TextureTarget, - pParameter TextureParameter, - pValue float32, -) *GlTexParameterf +func NewGlTexParameterf(Target TextureTarget, Parameter TextureParameter, Value float32) *GlTexParameterf ``` #### func (*GlTexParameterf) API @@ -13714,6 +20265,22 @@ func NewGlTexParameterf( func (c *GlTexParameterf) API() gfxapi.API ``` +#### func (*GlTexParameterf) AddRead + +```go +func (a *GlTexParameterf) AddRead(rng memory.Range, id binary.ID) *GlTexParameterf +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexParameterf pointer is returned so that calls can be chained. + +#### func (*GlTexParameterf) AddWrite + +```go +func (a *GlTexParameterf) AddWrite(rng memory.Range, id binary.ID) *GlTexParameterf +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexParameterf pointer is returned so that calls can be chained. + #### func (*GlTexParameterf) Class ```go @@ -13729,19 +20296,25 @@ func (c *GlTexParameterf) Flags() atom.Flags #### func (*GlTexParameterf) Mutate ```go -func (ϟa *GlTexParameterf) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexParameterf) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexParameterf) Observations + +```go +func (a *GlTexParameterf) Observations() *atom.Observations ``` #### func (*GlTexParameterf) Replay ```go -func (ϟa *GlTexParameterf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexParameterf) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexParameterf) String ```go -func (c *GlTexParameterf) String() string +func (a *GlTexParameterf) String() string ``` #### func (*GlTexParameterf) TypeID @@ -13755,6 +20328,7 @@ func (c *GlTexParameterf) TypeID() atom.TypeID ```go type GlTexParameteri struct { binary.Generate + Target TextureTarget Parameter TextureParameter Value int32 @@ -13768,11 +20342,7 @@ GlTexParameteri #### func NewGlTexParameteri ```go -func NewGlTexParameteri( - pTarget TextureTarget, - pParameter TextureParameter, - pValue int32, -) *GlTexParameteri +func NewGlTexParameteri(Target TextureTarget, Parameter TextureParameter, Value int32) *GlTexParameteri ``` #### func (*GlTexParameteri) API @@ -13781,6 +20351,22 @@ func NewGlTexParameteri( func (c *GlTexParameteri) API() gfxapi.API ``` +#### func (*GlTexParameteri) AddRead + +```go +func (a *GlTexParameteri) AddRead(rng memory.Range, id binary.ID) *GlTexParameteri +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexParameteri pointer is returned so that calls can be chained. + +#### func (*GlTexParameteri) AddWrite + +```go +func (a *GlTexParameteri) AddWrite(rng memory.Range, id binary.ID) *GlTexParameteri +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexParameteri pointer is returned so that calls can be chained. + #### func (*GlTexParameteri) Class ```go @@ -13796,19 +20382,25 @@ func (c *GlTexParameteri) Flags() atom.Flags #### func (*GlTexParameteri) Mutate ```go -func (ϟa *GlTexParameteri) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexParameteri) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexParameteri) Observations + +```go +func (a *GlTexParameteri) Observations() *atom.Observations ``` #### func (*GlTexParameteri) Replay ```go -func (ϟa *GlTexParameteri) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexParameteri) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexParameteri) String ```go -func (c *GlTexParameteri) String() string +func (a *GlTexParameteri) String() string ``` #### func (*GlTexParameteri) TypeID @@ -13822,6 +20414,7 @@ func (c *GlTexParameteri) TypeID() atom.TypeID ```go type GlTexStorage1DEXT struct { binary.Generate + Target TextureTarget Levels int32 Format TexelFormat @@ -13836,12 +20429,7 @@ GlTexStorage1DEXT #### func NewGlTexStorage1DEXT ```go -func NewGlTexStorage1DEXT( - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, -) *GlTexStorage1DEXT +func NewGlTexStorage1DEXT(Target TextureTarget, Levels int32, Format TexelFormat, Width int32) *GlTexStorage1DEXT ``` #### func (*GlTexStorage1DEXT) API @@ -13850,6 +20438,22 @@ func NewGlTexStorage1DEXT( func (c *GlTexStorage1DEXT) API() gfxapi.API ``` +#### func (*GlTexStorage1DEXT) AddRead + +```go +func (a *GlTexStorage1DEXT) AddRead(rng memory.Range, id binary.ID) *GlTexStorage1DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexStorage1DEXT pointer is returned so that calls can be chained. + +#### func (*GlTexStorage1DEXT) AddWrite + +```go +func (a *GlTexStorage1DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTexStorage1DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexStorage1DEXT pointer is returned so that calls can be chained. + #### func (*GlTexStorage1DEXT) Class ```go @@ -13865,19 +20469,25 @@ func (c *GlTexStorage1DEXT) Flags() atom.Flags #### func (*GlTexStorage1DEXT) Mutate ```go -func (ϟa *GlTexStorage1DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexStorage1DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexStorage1DEXT) Observations + +```go +func (a *GlTexStorage1DEXT) Observations() *atom.Observations ``` #### func (*GlTexStorage1DEXT) Replay ```go -func (ϟa *GlTexStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexStorage1DEXT) String ```go -func (c *GlTexStorage1DEXT) String() string +func (a *GlTexStorage1DEXT) String() string ``` #### func (*GlTexStorage1DEXT) TypeID @@ -13891,6 +20501,7 @@ func (c *GlTexStorage1DEXT) TypeID() atom.TypeID ```go type GlTexStorage2DEXT struct { binary.Generate + Target TextureTarget Levels int32 Format TexelFormat @@ -13906,13 +20517,7 @@ GlTexStorage2DEXT #### func NewGlTexStorage2DEXT ```go -func NewGlTexStorage2DEXT( - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, - pHeight int32, -) *GlTexStorage2DEXT +func NewGlTexStorage2DEXT(Target TextureTarget, Levels int32, Format TexelFormat, Width int32, Height int32) *GlTexStorage2DEXT ``` #### func (*GlTexStorage2DEXT) API @@ -13921,6 +20526,22 @@ func NewGlTexStorage2DEXT( func (c *GlTexStorage2DEXT) API() gfxapi.API ``` +#### func (*GlTexStorage2DEXT) AddRead + +```go +func (a *GlTexStorage2DEXT) AddRead(rng memory.Range, id binary.ID) *GlTexStorage2DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexStorage2DEXT pointer is returned so that calls can be chained. + +#### func (*GlTexStorage2DEXT) AddWrite + +```go +func (a *GlTexStorage2DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTexStorage2DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexStorage2DEXT pointer is returned so that calls can be chained. + #### func (*GlTexStorage2DEXT) Class ```go @@ -13936,19 +20557,25 @@ func (c *GlTexStorage2DEXT) Flags() atom.Flags #### func (*GlTexStorage2DEXT) Mutate ```go -func (ϟa *GlTexStorage2DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexStorage2DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexStorage2DEXT) Observations + +```go +func (a *GlTexStorage2DEXT) Observations() *atom.Observations ``` #### func (*GlTexStorage2DEXT) Replay ```go -func (ϟa *GlTexStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexStorage2DEXT) String ```go -func (c *GlTexStorage2DEXT) String() string +func (a *GlTexStorage2DEXT) String() string ``` #### func (*GlTexStorage2DEXT) TypeID @@ -13962,6 +20589,7 @@ func (c *GlTexStorage2DEXT) TypeID() atom.TypeID ```go type GlTexStorage3DEXT struct { binary.Generate + Target TextureTarget Levels int32 Format TexelFormat @@ -13978,14 +20606,7 @@ GlTexStorage3DEXT #### func NewGlTexStorage3DEXT ```go -func NewGlTexStorage3DEXT( - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, - pHeight int32, - pDepth int32, -) *GlTexStorage3DEXT +func NewGlTexStorage3DEXT(Target TextureTarget, Levels int32, Format TexelFormat, Width int32, Height int32, Depth int32) *GlTexStorage3DEXT ``` #### func (*GlTexStorage3DEXT) API @@ -13994,6 +20615,22 @@ func NewGlTexStorage3DEXT( func (c *GlTexStorage3DEXT) API() gfxapi.API ``` +#### func (*GlTexStorage3DEXT) AddRead + +```go +func (a *GlTexStorage3DEXT) AddRead(rng memory.Range, id binary.ID) *GlTexStorage3DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexStorage3DEXT pointer is returned so that calls can be chained. + +#### func (*GlTexStorage3DEXT) AddWrite + +```go +func (a *GlTexStorage3DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTexStorage3DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexStorage3DEXT pointer is returned so that calls can be chained. + #### func (*GlTexStorage3DEXT) Class ```go @@ -14009,19 +20646,25 @@ func (c *GlTexStorage3DEXT) Flags() atom.Flags #### func (*GlTexStorage3DEXT) Mutate ```go -func (ϟa *GlTexStorage3DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexStorage3DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexStorage3DEXT) Observations + +```go +func (a *GlTexStorage3DEXT) Observations() *atom.Observations ``` #### func (*GlTexStorage3DEXT) Replay ```go -func (ϟa *GlTexStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexStorage3DEXT) String ```go -func (c *GlTexStorage3DEXT) String() string +func (a *GlTexStorage3DEXT) String() string ``` #### func (*GlTexStorage3DEXT) TypeID @@ -14035,6 +20678,7 @@ func (c *GlTexStorage3DEXT) TypeID() atom.TypeID ```go type GlTexSubImage2D struct { binary.Generate + Target TextureImageTarget Level int32 Xoffset int32 @@ -14054,17 +20698,7 @@ GlTexSubImage2D #### func NewGlTexSubImage2D ```go -func NewGlTexSubImage2D( - pTarget TextureImageTarget, - pLevel int32, - pXoffset int32, - pYoffset int32, - pWidth int32, - pHeight int32, - pFormat TexelFormat, - pType TexelType, - pData TexturePointer, -) *GlTexSubImage2D +func NewGlTexSubImage2D(Target TextureImageTarget, Level int32, Xoffset int32, Yoffset int32, Width int32, Height int32, Format TexelFormat, Type TexelType, Data memory.Pointer) *GlTexSubImage2D ``` #### func (*GlTexSubImage2D) API @@ -14073,6 +20707,22 @@ func NewGlTexSubImage2D( func (c *GlTexSubImage2D) API() gfxapi.API ``` +#### func (*GlTexSubImage2D) AddRead + +```go +func (a *GlTexSubImage2D) AddRead(rng memory.Range, id binary.ID) *GlTexSubImage2D +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTexSubImage2D pointer is returned so that calls can be chained. + +#### func (*GlTexSubImage2D) AddWrite + +```go +func (a *GlTexSubImage2D) AddWrite(rng memory.Range, id binary.ID) *GlTexSubImage2D +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTexSubImage2D pointer is returned so that calls can be chained. + #### func (*GlTexSubImage2D) Class ```go @@ -14088,19 +20738,25 @@ func (c *GlTexSubImage2D) Flags() atom.Flags #### func (*GlTexSubImage2D) Mutate ```go -func (ϟa *GlTexSubImage2D) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTexSubImage2D) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTexSubImage2D) Observations + +```go +func (a *GlTexSubImage2D) Observations() *atom.Observations ``` #### func (*GlTexSubImage2D) Replay ```go -func (ϟa *GlTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTexSubImage2D) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTexSubImage2D) String ```go -func (c *GlTexSubImage2D) String() string +func (a *GlTexSubImage2D) String() string ``` #### func (*GlTexSubImage2D) TypeID @@ -14114,6 +20770,7 @@ func (c *GlTexSubImage2D) TypeID() atom.TypeID ```go type GlTextureStorage1DEXT struct { binary.Generate + Texture TextureId Target TextureTarget Levels int32 @@ -14129,13 +20786,7 @@ GlTextureStorage1DEXT #### func NewGlTextureStorage1DEXT ```go -func NewGlTextureStorage1DEXT( - pTexture TextureId, - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, -) *GlTextureStorage1DEXT +func NewGlTextureStorage1DEXT(Texture TextureId, Target TextureTarget, Levels int32, Format TexelFormat, Width int32) *GlTextureStorage1DEXT ``` #### func (*GlTextureStorage1DEXT) API @@ -14144,6 +20795,24 @@ func NewGlTextureStorage1DEXT( func (c *GlTextureStorage1DEXT) API() gfxapi.API ``` +#### func (*GlTextureStorage1DEXT) AddRead + +```go +func (a *GlTextureStorage1DEXT) AddRead(rng memory.Range, id binary.ID) *GlTextureStorage1DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTextureStorage1DEXT pointer is returned so that calls can be +chained. + +#### func (*GlTextureStorage1DEXT) AddWrite + +```go +func (a *GlTextureStorage1DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTextureStorage1DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTextureStorage1DEXT pointer is returned so that calls can be +chained. + #### func (*GlTextureStorage1DEXT) Class ```go @@ -14159,19 +20828,25 @@ func (c *GlTextureStorage1DEXT) Flags() atom.Flags #### func (*GlTextureStorage1DEXT) Mutate ```go -func (ϟa *GlTextureStorage1DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTextureStorage1DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTextureStorage1DEXT) Observations + +```go +func (a *GlTextureStorage1DEXT) Observations() *atom.Observations ``` #### func (*GlTextureStorage1DEXT) Replay ```go -func (ϟa *GlTextureStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTextureStorage1DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTextureStorage1DEXT) String ```go -func (c *GlTextureStorage1DEXT) String() string +func (a *GlTextureStorage1DEXT) String() string ``` #### func (*GlTextureStorage1DEXT) TypeID @@ -14185,6 +20860,7 @@ func (c *GlTextureStorage1DEXT) TypeID() atom.TypeID ```go type GlTextureStorage2DEXT struct { binary.Generate + Texture TextureId Target TextureTarget Levels int32 @@ -14201,14 +20877,7 @@ GlTextureStorage2DEXT #### func NewGlTextureStorage2DEXT ```go -func NewGlTextureStorage2DEXT( - pTexture TextureId, - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, - pHeight int32, -) *GlTextureStorage2DEXT +func NewGlTextureStorage2DEXT(Texture TextureId, Target TextureTarget, Levels int32, Format TexelFormat, Width int32, Height int32) *GlTextureStorage2DEXT ``` #### func (*GlTextureStorage2DEXT) API @@ -14217,6 +20886,24 @@ func NewGlTextureStorage2DEXT( func (c *GlTextureStorage2DEXT) API() gfxapi.API ``` +#### func (*GlTextureStorage2DEXT) AddRead + +```go +func (a *GlTextureStorage2DEXT) AddRead(rng memory.Range, id binary.ID) *GlTextureStorage2DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTextureStorage2DEXT pointer is returned so that calls can be +chained. + +#### func (*GlTextureStorage2DEXT) AddWrite + +```go +func (a *GlTextureStorage2DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTextureStorage2DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTextureStorage2DEXT pointer is returned so that calls can be +chained. + #### func (*GlTextureStorage2DEXT) Class ```go @@ -14232,19 +20919,25 @@ func (c *GlTextureStorage2DEXT) Flags() atom.Flags #### func (*GlTextureStorage2DEXT) Mutate ```go -func (ϟa *GlTextureStorage2DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTextureStorage2DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTextureStorage2DEXT) Observations + +```go +func (a *GlTextureStorage2DEXT) Observations() *atom.Observations ``` #### func (*GlTextureStorage2DEXT) Replay ```go -func (ϟa *GlTextureStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTextureStorage2DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTextureStorage2DEXT) String ```go -func (c *GlTextureStorage2DEXT) String() string +func (a *GlTextureStorage2DEXT) String() string ``` #### func (*GlTextureStorage2DEXT) TypeID @@ -14258,6 +20951,7 @@ func (c *GlTextureStorage2DEXT) TypeID() atom.TypeID ```go type GlTextureStorage3DEXT struct { binary.Generate + Texture TextureId Target TextureTarget Levels int32 @@ -14275,15 +20969,7 @@ GlTextureStorage3DEXT #### func NewGlTextureStorage3DEXT ```go -func NewGlTextureStorage3DEXT( - pTexture TextureId, - pTarget TextureTarget, - pLevels int32, - pFormat TexelFormat, - pWidth int32, - pHeight int32, - pDepth int32, -) *GlTextureStorage3DEXT +func NewGlTextureStorage3DEXT(Texture TextureId, Target TextureTarget, Levels int32, Format TexelFormat, Width int32, Height int32, Depth int32) *GlTextureStorage3DEXT ``` #### func (*GlTextureStorage3DEXT) API @@ -14292,6 +20978,24 @@ func NewGlTextureStorage3DEXT( func (c *GlTextureStorage3DEXT) API() gfxapi.API ``` +#### func (*GlTextureStorage3DEXT) AddRead + +```go +func (a *GlTextureStorage3DEXT) AddRead(rng memory.Range, id binary.ID) *GlTextureStorage3DEXT +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlTextureStorage3DEXT pointer is returned so that calls can be +chained. + +#### func (*GlTextureStorage3DEXT) AddWrite + +```go +func (a *GlTextureStorage3DEXT) AddWrite(rng memory.Range, id binary.ID) *GlTextureStorage3DEXT +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlTextureStorage3DEXT pointer is returned so that calls can be +chained. + #### func (*GlTextureStorage3DEXT) Class ```go @@ -14307,19 +21011,25 @@ func (c *GlTextureStorage3DEXT) Flags() atom.Flags #### func (*GlTextureStorage3DEXT) Mutate ```go -func (ϟa *GlTextureStorage3DEXT) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlTextureStorage3DEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlTextureStorage3DEXT) Observations + +```go +func (a *GlTextureStorage3DEXT) Observations() *atom.Observations ``` #### func (*GlTextureStorage3DEXT) Replay ```go -func (ϟa *GlTextureStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlTextureStorage3DEXT) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlTextureStorage3DEXT) String ```go -func (c *GlTextureStorage3DEXT) String() string +func (a *GlTextureStorage3DEXT) String() string ``` #### func (*GlTextureStorage3DEXT) TypeID @@ -14333,6 +21043,7 @@ func (c *GlTextureStorage3DEXT) TypeID() atom.TypeID ```go type GlUniform1f struct { binary.Generate + Location UniformLocation Value float32 } @@ -14345,10 +21056,7 @@ GlUniform1f #### func NewGlUniform1f ```go -func NewGlUniform1f( - pLocation UniformLocation, - pValue float32, -) *GlUniform1f +func NewGlUniform1f(Location UniformLocation, Value float32) *GlUniform1f ``` #### func (*GlUniform1f) API @@ -14357,6 +21065,22 @@ func NewGlUniform1f( func (c *GlUniform1f) API() gfxapi.API ``` +#### func (*GlUniform1f) AddRead + +```go +func (a *GlUniform1f) AddRead(rng memory.Range, id binary.ID) *GlUniform1f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform1f pointer is returned so that calls can be chained. + +#### func (*GlUniform1f) AddWrite + +```go +func (a *GlUniform1f) AddWrite(rng memory.Range, id binary.ID) *GlUniform1f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform1f pointer is returned so that calls can be chained. + #### func (*GlUniform1f) Class ```go @@ -14372,19 +21096,25 @@ func (c *GlUniform1f) Flags() atom.Flags #### func (*GlUniform1f) Mutate ```go -func (ϟa *GlUniform1f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform1f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform1f) Observations + +```go +func (a *GlUniform1f) Observations() *atom.Observations ``` #### func (*GlUniform1f) Replay ```go -func (ϟa *GlUniform1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform1f) String ```go -func (c *GlUniform1f) String() string +func (a *GlUniform1f) String() string ``` #### func (*GlUniform1f) TypeID @@ -14398,9 +21128,10 @@ func (c *GlUniform1f) TypeID() atom.TypeID ```go type GlUniform1fv struct { binary.Generate + Location UniformLocation Count int32 - Value F32Array + Values F32ᵖ } ``` @@ -14411,11 +21142,7 @@ GlUniform1fv #### func NewGlUniform1fv ```go -func NewGlUniform1fv( - pLocation UniformLocation, - pCount int32, - pValue F32Array, -) *GlUniform1fv +func NewGlUniform1fv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform1fv ``` #### func (*GlUniform1fv) API @@ -14424,6 +21151,22 @@ func NewGlUniform1fv( func (c *GlUniform1fv) API() gfxapi.API ``` +#### func (*GlUniform1fv) AddRead + +```go +func (a *GlUniform1fv) AddRead(rng memory.Range, id binary.ID) *GlUniform1fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform1fv pointer is returned so that calls can be chained. + +#### func (*GlUniform1fv) AddWrite + +```go +func (a *GlUniform1fv) AddWrite(rng memory.Range, id binary.ID) *GlUniform1fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform1fv pointer is returned so that calls can be chained. + #### func (*GlUniform1fv) Class ```go @@ -14439,19 +21182,25 @@ func (c *GlUniform1fv) Flags() atom.Flags #### func (*GlUniform1fv) Mutate ```go -func (ϟa *GlUniform1fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform1fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform1fv) Observations + +```go +func (a *GlUniform1fv) Observations() *atom.Observations ``` #### func (*GlUniform1fv) Replay ```go -func (ϟa *GlUniform1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform1fv) String ```go -func (c *GlUniform1fv) String() string +func (a *GlUniform1fv) String() string ``` #### func (*GlUniform1fv) TypeID @@ -14465,6 +21214,7 @@ func (c *GlUniform1fv) TypeID() atom.TypeID ```go type GlUniform1i struct { binary.Generate + Location UniformLocation Value int32 } @@ -14477,10 +21227,7 @@ GlUniform1i #### func NewGlUniform1i ```go -func NewGlUniform1i( - pLocation UniformLocation, - pValue int32, -) *GlUniform1i +func NewGlUniform1i(Location UniformLocation, Value int32) *GlUniform1i ``` #### func (*GlUniform1i) API @@ -14489,6 +21236,22 @@ func NewGlUniform1i( func (c *GlUniform1i) API() gfxapi.API ``` +#### func (*GlUniform1i) AddRead + +```go +func (a *GlUniform1i) AddRead(rng memory.Range, id binary.ID) *GlUniform1i +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform1i pointer is returned so that calls can be chained. + +#### func (*GlUniform1i) AddWrite + +```go +func (a *GlUniform1i) AddWrite(rng memory.Range, id binary.ID) *GlUniform1i +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform1i pointer is returned so that calls can be chained. + #### func (*GlUniform1i) Class ```go @@ -14504,19 +21267,25 @@ func (c *GlUniform1i) Flags() atom.Flags #### func (*GlUniform1i) Mutate ```go -func (ϟa *GlUniform1i) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform1i) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform1i) Observations + +```go +func (a *GlUniform1i) Observations() *atom.Observations ``` #### func (*GlUniform1i) Replay ```go -func (ϟa *GlUniform1i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform1i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform1i) String ```go -func (c *GlUniform1i) String() string +func (a *GlUniform1i) String() string ``` #### func (*GlUniform1i) TypeID @@ -14530,9 +21299,10 @@ func (c *GlUniform1i) TypeID() atom.TypeID ```go type GlUniform1iv struct { binary.Generate + Location UniformLocation Count int32 - Value S32Array + Values S32ᵖ } ``` @@ -14543,11 +21313,7 @@ GlUniform1iv #### func NewGlUniform1iv ```go -func NewGlUniform1iv( - pLocation UniformLocation, - pCount int32, - pValue S32Array, -) *GlUniform1iv +func NewGlUniform1iv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform1iv ``` #### func (*GlUniform1iv) API @@ -14556,6 +21322,22 @@ func NewGlUniform1iv( func (c *GlUniform1iv) API() gfxapi.API ``` +#### func (*GlUniform1iv) AddRead + +```go +func (a *GlUniform1iv) AddRead(rng memory.Range, id binary.ID) *GlUniform1iv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform1iv pointer is returned so that calls can be chained. + +#### func (*GlUniform1iv) AddWrite + +```go +func (a *GlUniform1iv) AddWrite(rng memory.Range, id binary.ID) *GlUniform1iv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform1iv pointer is returned so that calls can be chained. + #### func (*GlUniform1iv) Class ```go @@ -14571,19 +21353,25 @@ func (c *GlUniform1iv) Flags() atom.Flags #### func (*GlUniform1iv) Mutate ```go -func (ϟa *GlUniform1iv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform1iv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform1iv) Observations + +```go +func (a *GlUniform1iv) Observations() *atom.Observations ``` #### func (*GlUniform1iv) Replay ```go -func (ϟa *GlUniform1iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform1iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform1iv) String ```go -func (c *GlUniform1iv) String() string +func (a *GlUniform1iv) String() string ``` #### func (*GlUniform1iv) TypeID @@ -14597,6 +21385,7 @@ func (c *GlUniform1iv) TypeID() atom.TypeID ```go type GlUniform2f struct { binary.Generate + Location UniformLocation Value0 float32 Value1 float32 @@ -14610,11 +21399,7 @@ GlUniform2f #### func NewGlUniform2f ```go -func NewGlUniform2f( - pLocation UniformLocation, - pValue0 float32, - pValue1 float32, -) *GlUniform2f +func NewGlUniform2f(Location UniformLocation, Value0 float32, Value1 float32) *GlUniform2f ``` #### func (*GlUniform2f) API @@ -14623,6 +21408,22 @@ func NewGlUniform2f( func (c *GlUniform2f) API() gfxapi.API ``` +#### func (*GlUniform2f) AddRead + +```go +func (a *GlUniform2f) AddRead(rng memory.Range, id binary.ID) *GlUniform2f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform2f pointer is returned so that calls can be chained. + +#### func (*GlUniform2f) AddWrite + +```go +func (a *GlUniform2f) AddWrite(rng memory.Range, id binary.ID) *GlUniform2f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform2f pointer is returned so that calls can be chained. + #### func (*GlUniform2f) Class ```go @@ -14638,19 +21439,25 @@ func (c *GlUniform2f) Flags() atom.Flags #### func (*GlUniform2f) Mutate ```go -func (ϟa *GlUniform2f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform2f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform2f) Observations + +```go +func (a *GlUniform2f) Observations() *atom.Observations ``` #### func (*GlUniform2f) Replay ```go -func (ϟa *GlUniform2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform2f) String ```go -func (c *GlUniform2f) String() string +func (a *GlUniform2f) String() string ``` #### func (*GlUniform2f) TypeID @@ -14664,9 +21471,10 @@ func (c *GlUniform2f) TypeID() atom.TypeID ```go type GlUniform2fv struct { binary.Generate + Location UniformLocation Count int32 - Value F32Array + Values F32ᵖ } ``` @@ -14677,11 +21485,7 @@ GlUniform2fv #### func NewGlUniform2fv ```go -func NewGlUniform2fv( - pLocation UniformLocation, - pCount int32, - pValue F32Array, -) *GlUniform2fv +func NewGlUniform2fv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform2fv ``` #### func (*GlUniform2fv) API @@ -14690,6 +21494,22 @@ func NewGlUniform2fv( func (c *GlUniform2fv) API() gfxapi.API ``` +#### func (*GlUniform2fv) AddRead + +```go +func (a *GlUniform2fv) AddRead(rng memory.Range, id binary.ID) *GlUniform2fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform2fv pointer is returned so that calls can be chained. + +#### func (*GlUniform2fv) AddWrite + +```go +func (a *GlUniform2fv) AddWrite(rng memory.Range, id binary.ID) *GlUniform2fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform2fv pointer is returned so that calls can be chained. + #### func (*GlUniform2fv) Class ```go @@ -14705,19 +21525,25 @@ func (c *GlUniform2fv) Flags() atom.Flags #### func (*GlUniform2fv) Mutate ```go -func (ϟa *GlUniform2fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform2fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform2fv) Observations + +```go +func (a *GlUniform2fv) Observations() *atom.Observations ``` #### func (*GlUniform2fv) Replay ```go -func (ϟa *GlUniform2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform2fv) String ```go -func (c *GlUniform2fv) String() string +func (a *GlUniform2fv) String() string ``` #### func (*GlUniform2fv) TypeID @@ -14731,6 +21557,7 @@ func (c *GlUniform2fv) TypeID() atom.TypeID ```go type GlUniform2i struct { binary.Generate + Location UniformLocation Value0 int32 Value1 int32 @@ -14744,11 +21571,7 @@ GlUniform2i #### func NewGlUniform2i ```go -func NewGlUniform2i( - pLocation UniformLocation, - pValue0 int32, - pValue1 int32, -) *GlUniform2i +func NewGlUniform2i(Location UniformLocation, Value0 int32, Value1 int32) *GlUniform2i ``` #### func (*GlUniform2i) API @@ -14757,6 +21580,22 @@ func NewGlUniform2i( func (c *GlUniform2i) API() gfxapi.API ``` +#### func (*GlUniform2i) AddRead + +```go +func (a *GlUniform2i) AddRead(rng memory.Range, id binary.ID) *GlUniform2i +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform2i pointer is returned so that calls can be chained. + +#### func (*GlUniform2i) AddWrite + +```go +func (a *GlUniform2i) AddWrite(rng memory.Range, id binary.ID) *GlUniform2i +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform2i pointer is returned so that calls can be chained. + #### func (*GlUniform2i) Class ```go @@ -14772,19 +21611,25 @@ func (c *GlUniform2i) Flags() atom.Flags #### func (*GlUniform2i) Mutate ```go -func (ϟa *GlUniform2i) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform2i) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform2i) Observations + +```go +func (a *GlUniform2i) Observations() *atom.Observations ``` #### func (*GlUniform2i) Replay ```go -func (ϟa *GlUniform2i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform2i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform2i) String ```go -func (c *GlUniform2i) String() string +func (a *GlUniform2i) String() string ``` #### func (*GlUniform2i) TypeID @@ -14798,9 +21643,10 @@ func (c *GlUniform2i) TypeID() atom.TypeID ```go type GlUniform2iv struct { binary.Generate + Location UniformLocation Count int32 - Value S32Array + Values S32ᵖ } ``` @@ -14811,11 +21657,7 @@ GlUniform2iv #### func NewGlUniform2iv ```go -func NewGlUniform2iv( - pLocation UniformLocation, - pCount int32, - pValue S32Array, -) *GlUniform2iv +func NewGlUniform2iv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform2iv ``` #### func (*GlUniform2iv) API @@ -14824,6 +21666,22 @@ func NewGlUniform2iv( func (c *GlUniform2iv) API() gfxapi.API ``` +#### func (*GlUniform2iv) AddRead + +```go +func (a *GlUniform2iv) AddRead(rng memory.Range, id binary.ID) *GlUniform2iv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform2iv pointer is returned so that calls can be chained. + +#### func (*GlUniform2iv) AddWrite + +```go +func (a *GlUniform2iv) AddWrite(rng memory.Range, id binary.ID) *GlUniform2iv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform2iv pointer is returned so that calls can be chained. + #### func (*GlUniform2iv) Class ```go @@ -14839,19 +21697,25 @@ func (c *GlUniform2iv) Flags() atom.Flags #### func (*GlUniform2iv) Mutate ```go -func (ϟa *GlUniform2iv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform2iv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform2iv) Observations + +```go +func (a *GlUniform2iv) Observations() *atom.Observations ``` #### func (*GlUniform2iv) Replay ```go -func (ϟa *GlUniform2iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform2iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform2iv) String ```go -func (c *GlUniform2iv) String() string +func (a *GlUniform2iv) String() string ``` #### func (*GlUniform2iv) TypeID @@ -14865,6 +21729,7 @@ func (c *GlUniform2iv) TypeID() atom.TypeID ```go type GlUniform3f struct { binary.Generate + Location UniformLocation Value0 float32 Value1 float32 @@ -14879,12 +21744,7 @@ GlUniform3f #### func NewGlUniform3f ```go -func NewGlUniform3f( - pLocation UniformLocation, - pValue0 float32, - pValue1 float32, - pValue2 float32, -) *GlUniform3f +func NewGlUniform3f(Location UniformLocation, Value0 float32, Value1 float32, Value2 float32) *GlUniform3f ``` #### func (*GlUniform3f) API @@ -14893,6 +21753,22 @@ func NewGlUniform3f( func (c *GlUniform3f) API() gfxapi.API ``` +#### func (*GlUniform3f) AddRead + +```go +func (a *GlUniform3f) AddRead(rng memory.Range, id binary.ID) *GlUniform3f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform3f pointer is returned so that calls can be chained. + +#### func (*GlUniform3f) AddWrite + +```go +func (a *GlUniform3f) AddWrite(rng memory.Range, id binary.ID) *GlUniform3f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform3f pointer is returned so that calls can be chained. + #### func (*GlUniform3f) Class ```go @@ -14908,19 +21784,25 @@ func (c *GlUniform3f) Flags() atom.Flags #### func (*GlUniform3f) Mutate ```go -func (ϟa *GlUniform3f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform3f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform3f) Observations + +```go +func (a *GlUniform3f) Observations() *atom.Observations ``` #### func (*GlUniform3f) Replay ```go -func (ϟa *GlUniform3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform3f) String ```go -func (c *GlUniform3f) String() string +func (a *GlUniform3f) String() string ``` #### func (*GlUniform3f) TypeID @@ -14934,9 +21816,10 @@ func (c *GlUniform3f) TypeID() atom.TypeID ```go type GlUniform3fv struct { binary.Generate + Location UniformLocation Count int32 - Value F32Array + Values F32ᵖ } ``` @@ -14947,11 +21830,7 @@ GlUniform3fv #### func NewGlUniform3fv ```go -func NewGlUniform3fv( - pLocation UniformLocation, - pCount int32, - pValue F32Array, -) *GlUniform3fv +func NewGlUniform3fv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform3fv ``` #### func (*GlUniform3fv) API @@ -14960,6 +21839,22 @@ func NewGlUniform3fv( func (c *GlUniform3fv) API() gfxapi.API ``` +#### func (*GlUniform3fv) AddRead + +```go +func (a *GlUniform3fv) AddRead(rng memory.Range, id binary.ID) *GlUniform3fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform3fv pointer is returned so that calls can be chained. + +#### func (*GlUniform3fv) AddWrite + +```go +func (a *GlUniform3fv) AddWrite(rng memory.Range, id binary.ID) *GlUniform3fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform3fv pointer is returned so that calls can be chained. + #### func (*GlUniform3fv) Class ```go @@ -14975,19 +21870,25 @@ func (c *GlUniform3fv) Flags() atom.Flags #### func (*GlUniform3fv) Mutate ```go -func (ϟa *GlUniform3fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform3fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform3fv) Observations + +```go +func (a *GlUniform3fv) Observations() *atom.Observations ``` #### func (*GlUniform3fv) Replay ```go -func (ϟa *GlUniform3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform3fv) String ```go -func (c *GlUniform3fv) String() string +func (a *GlUniform3fv) String() string ``` #### func (*GlUniform3fv) TypeID @@ -15001,6 +21902,7 @@ func (c *GlUniform3fv) TypeID() atom.TypeID ```go type GlUniform3i struct { binary.Generate + Location UniformLocation Value0 int32 Value1 int32 @@ -15015,12 +21917,7 @@ GlUniform3i #### func NewGlUniform3i ```go -func NewGlUniform3i( - pLocation UniformLocation, - pValue0 int32, - pValue1 int32, - pValue2 int32, -) *GlUniform3i +func NewGlUniform3i(Location UniformLocation, Value0 int32, Value1 int32, Value2 int32) *GlUniform3i ``` #### func (*GlUniform3i) API @@ -15029,6 +21926,22 @@ func NewGlUniform3i( func (c *GlUniform3i) API() gfxapi.API ``` +#### func (*GlUniform3i) AddRead + +```go +func (a *GlUniform3i) AddRead(rng memory.Range, id binary.ID) *GlUniform3i +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform3i pointer is returned so that calls can be chained. + +#### func (*GlUniform3i) AddWrite + +```go +func (a *GlUniform3i) AddWrite(rng memory.Range, id binary.ID) *GlUniform3i +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform3i pointer is returned so that calls can be chained. + #### func (*GlUniform3i) Class ```go @@ -15044,19 +21957,25 @@ func (c *GlUniform3i) Flags() atom.Flags #### func (*GlUniform3i) Mutate ```go -func (ϟa *GlUniform3i) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform3i) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform3i) Observations + +```go +func (a *GlUniform3i) Observations() *atom.Observations ``` #### func (*GlUniform3i) Replay ```go -func (ϟa *GlUniform3i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform3i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform3i) String ```go -func (c *GlUniform3i) String() string +func (a *GlUniform3i) String() string ``` #### func (*GlUniform3i) TypeID @@ -15070,9 +21989,10 @@ func (c *GlUniform3i) TypeID() atom.TypeID ```go type GlUniform3iv struct { binary.Generate + Location UniformLocation Count int32 - Value S32Array + Values S32ᵖ } ``` @@ -15083,11 +22003,7 @@ GlUniform3iv #### func NewGlUniform3iv ```go -func NewGlUniform3iv( - pLocation UniformLocation, - pCount int32, - pValue S32Array, -) *GlUniform3iv +func NewGlUniform3iv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform3iv ``` #### func (*GlUniform3iv) API @@ -15096,6 +22012,22 @@ func NewGlUniform3iv( func (c *GlUniform3iv) API() gfxapi.API ``` +#### func (*GlUniform3iv) AddRead + +```go +func (a *GlUniform3iv) AddRead(rng memory.Range, id binary.ID) *GlUniform3iv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform3iv pointer is returned so that calls can be chained. + +#### func (*GlUniform3iv) AddWrite + +```go +func (a *GlUniform3iv) AddWrite(rng memory.Range, id binary.ID) *GlUniform3iv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform3iv pointer is returned so that calls can be chained. + #### func (*GlUniform3iv) Class ```go @@ -15111,19 +22043,25 @@ func (c *GlUniform3iv) Flags() atom.Flags #### func (*GlUniform3iv) Mutate ```go -func (ϟa *GlUniform3iv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform3iv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform3iv) Observations + +```go +func (a *GlUniform3iv) Observations() *atom.Observations ``` #### func (*GlUniform3iv) Replay ```go -func (ϟa *GlUniform3iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform3iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform3iv) String ```go -func (c *GlUniform3iv) String() string +func (a *GlUniform3iv) String() string ``` #### func (*GlUniform3iv) TypeID @@ -15137,6 +22075,7 @@ func (c *GlUniform3iv) TypeID() atom.TypeID ```go type GlUniform4f struct { binary.Generate + Location UniformLocation Value0 float32 Value1 float32 @@ -15152,13 +22091,7 @@ GlUniform4f #### func NewGlUniform4f ```go -func NewGlUniform4f( - pLocation UniformLocation, - pValue0 float32, - pValue1 float32, - pValue2 float32, - pValue3 float32, -) *GlUniform4f +func NewGlUniform4f(Location UniformLocation, Value0 float32, Value1 float32, Value2 float32, Value3 float32) *GlUniform4f ``` #### func (*GlUniform4f) API @@ -15167,6 +22100,22 @@ func NewGlUniform4f( func (c *GlUniform4f) API() gfxapi.API ``` +#### func (*GlUniform4f) AddRead + +```go +func (a *GlUniform4f) AddRead(rng memory.Range, id binary.ID) *GlUniform4f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform4f pointer is returned so that calls can be chained. + +#### func (*GlUniform4f) AddWrite + +```go +func (a *GlUniform4f) AddWrite(rng memory.Range, id binary.ID) *GlUniform4f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform4f pointer is returned so that calls can be chained. + #### func (*GlUniform4f) Class ```go @@ -15182,19 +22131,25 @@ func (c *GlUniform4f) Flags() atom.Flags #### func (*GlUniform4f) Mutate ```go -func (ϟa *GlUniform4f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform4f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform4f) Observations + +```go +func (a *GlUniform4f) Observations() *atom.Observations ``` #### func (*GlUniform4f) Replay ```go -func (ϟa *GlUniform4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform4f) String ```go -func (c *GlUniform4f) String() string +func (a *GlUniform4f) String() string ``` #### func (*GlUniform4f) TypeID @@ -15208,9 +22163,10 @@ func (c *GlUniform4f) TypeID() atom.TypeID ```go type GlUniform4fv struct { binary.Generate + Location UniformLocation Count int32 - Value F32Array + Values F32ᵖ } ``` @@ -15221,11 +22177,7 @@ GlUniform4fv #### func NewGlUniform4fv ```go -func NewGlUniform4fv( - pLocation UniformLocation, - pCount int32, - pValue F32Array, -) *GlUniform4fv +func NewGlUniform4fv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform4fv ``` #### func (*GlUniform4fv) API @@ -15234,6 +22186,22 @@ func NewGlUniform4fv( func (c *GlUniform4fv) API() gfxapi.API ``` +#### func (*GlUniform4fv) AddRead + +```go +func (a *GlUniform4fv) AddRead(rng memory.Range, id binary.ID) *GlUniform4fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform4fv pointer is returned so that calls can be chained. + +#### func (*GlUniform4fv) AddWrite + +```go +func (a *GlUniform4fv) AddWrite(rng memory.Range, id binary.ID) *GlUniform4fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform4fv pointer is returned so that calls can be chained. + #### func (*GlUniform4fv) Class ```go @@ -15249,19 +22217,25 @@ func (c *GlUniform4fv) Flags() atom.Flags #### func (*GlUniform4fv) Mutate ```go -func (ϟa *GlUniform4fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform4fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform4fv) Observations + +```go +func (a *GlUniform4fv) Observations() *atom.Observations ``` #### func (*GlUniform4fv) Replay ```go -func (ϟa *GlUniform4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform4fv) String ```go -func (c *GlUniform4fv) String() string +func (a *GlUniform4fv) String() string ``` #### func (*GlUniform4fv) TypeID @@ -15275,6 +22249,7 @@ func (c *GlUniform4fv) TypeID() atom.TypeID ```go type GlUniform4i struct { binary.Generate + Location UniformLocation Value0 int32 Value1 int32 @@ -15290,13 +22265,7 @@ GlUniform4i #### func NewGlUniform4i ```go -func NewGlUniform4i( - pLocation UniformLocation, - pValue0 int32, - pValue1 int32, - pValue2 int32, - pValue3 int32, -) *GlUniform4i +func NewGlUniform4i(Location UniformLocation, Value0 int32, Value1 int32, Value2 int32, Value3 int32) *GlUniform4i ``` #### func (*GlUniform4i) API @@ -15305,6 +22274,22 @@ func NewGlUniform4i( func (c *GlUniform4i) API() gfxapi.API ``` +#### func (*GlUniform4i) AddRead + +```go +func (a *GlUniform4i) AddRead(rng memory.Range, id binary.ID) *GlUniform4i +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform4i pointer is returned so that calls can be chained. + +#### func (*GlUniform4i) AddWrite + +```go +func (a *GlUniform4i) AddWrite(rng memory.Range, id binary.ID) *GlUniform4i +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform4i pointer is returned so that calls can be chained. + #### func (*GlUniform4i) Class ```go @@ -15320,19 +22305,25 @@ func (c *GlUniform4i) Flags() atom.Flags #### func (*GlUniform4i) Mutate ```go -func (ϟa *GlUniform4i) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform4i) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform4i) Observations + +```go +func (a *GlUniform4i) Observations() *atom.Observations ``` #### func (*GlUniform4i) Replay ```go -func (ϟa *GlUniform4i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform4i) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform4i) String ```go -func (c *GlUniform4i) String() string +func (a *GlUniform4i) String() string ``` #### func (*GlUniform4i) TypeID @@ -15346,9 +22337,10 @@ func (c *GlUniform4i) TypeID() atom.TypeID ```go type GlUniform4iv struct { binary.Generate + Location UniformLocation Count int32 - Value S32Array + Values S32ᵖ } ``` @@ -15359,11 +22351,7 @@ GlUniform4iv #### func NewGlUniform4iv ```go -func NewGlUniform4iv( - pLocation UniformLocation, - pCount int32, - pValue S32Array, -) *GlUniform4iv +func NewGlUniform4iv(Location UniformLocation, Count int32, Values memory.Pointer) *GlUniform4iv ``` #### func (*GlUniform4iv) API @@ -15372,6 +22360,22 @@ func NewGlUniform4iv( func (c *GlUniform4iv) API() gfxapi.API ``` +#### func (*GlUniform4iv) AddRead + +```go +func (a *GlUniform4iv) AddRead(rng memory.Range, id binary.ID) *GlUniform4iv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniform4iv pointer is returned so that calls can be chained. + +#### func (*GlUniform4iv) AddWrite + +```go +func (a *GlUniform4iv) AddWrite(rng memory.Range, id binary.ID) *GlUniform4iv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniform4iv pointer is returned so that calls can be chained. + #### func (*GlUniform4iv) Class ```go @@ -15387,19 +22391,25 @@ func (c *GlUniform4iv) Flags() atom.Flags #### func (*GlUniform4iv) Mutate ```go -func (ϟa *GlUniform4iv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniform4iv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniform4iv) Observations + +```go +func (a *GlUniform4iv) Observations() *atom.Observations ``` #### func (*GlUniform4iv) Replay ```go -func (ϟa *GlUniform4iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniform4iv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniform4iv) String ```go -func (c *GlUniform4iv) String() string +func (a *GlUniform4iv) String() string ``` #### func (*GlUniform4iv) TypeID @@ -15408,15 +22418,104 @@ func (c *GlUniform4iv) String() string func (c *GlUniform4iv) TypeID() atom.TypeID ``` +#### type GlUniformBlockBinding + +```go +type GlUniformBlockBinding struct { + binary.Generate + + Program ProgramId + UniformBlockIndex uint32 + UniformBlockBinding uint32 +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlUniformBlockBinding +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlUniformBlockBinding + +```go +func NewGlUniformBlockBinding(Program ProgramId, Uniform_block_index uint32, Uniform_block_binding uint32) *GlUniformBlockBinding +``` + +#### func (*GlUniformBlockBinding) API + +```go +func (c *GlUniformBlockBinding) API() gfxapi.API +``` + +#### func (*GlUniformBlockBinding) AddRead + +```go +func (a *GlUniformBlockBinding) AddRead(rng memory.Range, id binary.ID) *GlUniformBlockBinding +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniformBlockBinding pointer is returned so that calls can be +chained. + +#### func (*GlUniformBlockBinding) AddWrite + +```go +func (a *GlUniformBlockBinding) AddWrite(rng memory.Range, id binary.ID) *GlUniformBlockBinding +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniformBlockBinding pointer is returned so that calls can be +chained. + +#### func (*GlUniformBlockBinding) Class + +```go +func (*GlUniformBlockBinding) Class() binary.Class +``` + +#### func (*GlUniformBlockBinding) Flags + +```go +func (c *GlUniformBlockBinding) Flags() atom.Flags +``` + +#### func (*GlUniformBlockBinding) Mutate + +```go +func (ϟa *GlUniformBlockBinding) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniformBlockBinding) Observations + +```go +func (a *GlUniformBlockBinding) Observations() *atom.Observations +``` + +#### func (*GlUniformBlockBinding) Replay + +```go +func (ϟa *GlUniformBlockBinding) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlUniformBlockBinding) String + +```go +func (a *GlUniformBlockBinding) String() string +``` + +#### func (*GlUniformBlockBinding) TypeID + +```go +func (c *GlUniformBlockBinding) TypeID() atom.TypeID +``` + #### type GlUniformMatrix2fv ```go type GlUniformMatrix2fv struct { binary.Generate + Location UniformLocation Count int32 Transpose bool - Values F32Array + Values F32ᵖ } ``` @@ -15427,12 +22526,7 @@ GlUniformMatrix2fv #### func NewGlUniformMatrix2fv ```go -func NewGlUniformMatrix2fv( - pLocation UniformLocation, - pCount int32, - pTranspose bool, - pValues F32Array, -) *GlUniformMatrix2fv +func NewGlUniformMatrix2fv(Location UniformLocation, Count int32, Transpose bool, Values memory.Pointer) *GlUniformMatrix2fv ``` #### func (*GlUniformMatrix2fv) API @@ -15441,6 +22535,24 @@ func NewGlUniformMatrix2fv( func (c *GlUniformMatrix2fv) API() gfxapi.API ``` +#### func (*GlUniformMatrix2fv) AddRead + +```go +func (a *GlUniformMatrix2fv) AddRead(rng memory.Range, id binary.ID) *GlUniformMatrix2fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniformMatrix2fv pointer is returned so that calls can be +chained. + +#### func (*GlUniformMatrix2fv) AddWrite + +```go +func (a *GlUniformMatrix2fv) AddWrite(rng memory.Range, id binary.ID) *GlUniformMatrix2fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniformMatrix2fv pointer is returned so that calls can be +chained. + #### func (*GlUniformMatrix2fv) Class ```go @@ -15456,19 +22568,25 @@ func (c *GlUniformMatrix2fv) Flags() atom.Flags #### func (*GlUniformMatrix2fv) Mutate ```go -func (ϟa *GlUniformMatrix2fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniformMatrix2fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniformMatrix2fv) Observations + +```go +func (a *GlUniformMatrix2fv) Observations() *atom.Observations ``` #### func (*GlUniformMatrix2fv) Replay ```go -func (ϟa *GlUniformMatrix2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniformMatrix2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniformMatrix2fv) String ```go -func (c *GlUniformMatrix2fv) String() string +func (a *GlUniformMatrix2fv) String() string ``` #### func (*GlUniformMatrix2fv) TypeID @@ -15482,10 +22600,11 @@ func (c *GlUniformMatrix2fv) TypeID() atom.TypeID ```go type GlUniformMatrix3fv struct { binary.Generate + Location UniformLocation Count int32 Transpose bool - Values F32Array + Values F32ᵖ } ``` @@ -15496,12 +22615,7 @@ GlUniformMatrix3fv #### func NewGlUniformMatrix3fv ```go -func NewGlUniformMatrix3fv( - pLocation UniformLocation, - pCount int32, - pTranspose bool, - pValues F32Array, -) *GlUniformMatrix3fv +func NewGlUniformMatrix3fv(Location UniformLocation, Count int32, Transpose bool, Values memory.Pointer) *GlUniformMatrix3fv ``` #### func (*GlUniformMatrix3fv) API @@ -15510,6 +22624,24 @@ func NewGlUniformMatrix3fv( func (c *GlUniformMatrix3fv) API() gfxapi.API ``` +#### func (*GlUniformMatrix3fv) AddRead + +```go +func (a *GlUniformMatrix3fv) AddRead(rng memory.Range, id binary.ID) *GlUniformMatrix3fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniformMatrix3fv pointer is returned so that calls can be +chained. + +#### func (*GlUniformMatrix3fv) AddWrite + +```go +func (a *GlUniformMatrix3fv) AddWrite(rng memory.Range, id binary.ID) *GlUniformMatrix3fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniformMatrix3fv pointer is returned so that calls can be +chained. + #### func (*GlUniformMatrix3fv) Class ```go @@ -15525,19 +22657,25 @@ func (c *GlUniformMatrix3fv) Flags() atom.Flags #### func (*GlUniformMatrix3fv) Mutate ```go -func (ϟa *GlUniformMatrix3fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniformMatrix3fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniformMatrix3fv) Observations + +```go +func (a *GlUniformMatrix3fv) Observations() *atom.Observations ``` #### func (*GlUniformMatrix3fv) Replay ```go -func (ϟa *GlUniformMatrix3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniformMatrix3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniformMatrix3fv) String ```go -func (c *GlUniformMatrix3fv) String() string +func (a *GlUniformMatrix3fv) String() string ``` #### func (*GlUniformMatrix3fv) TypeID @@ -15551,10 +22689,11 @@ func (c *GlUniformMatrix3fv) TypeID() atom.TypeID ```go type GlUniformMatrix4fv struct { binary.Generate + Location UniformLocation Count int32 Transpose bool - Values F32Array + Values F32ᵖ } ``` @@ -15565,12 +22704,7 @@ GlUniformMatrix4fv #### func NewGlUniformMatrix4fv ```go -func NewGlUniformMatrix4fv( - pLocation UniformLocation, - pCount int32, - pTranspose bool, - pValues F32Array, -) *GlUniformMatrix4fv +func NewGlUniformMatrix4fv(Location UniformLocation, Count int32, Transpose bool, Values memory.Pointer) *GlUniformMatrix4fv ``` #### func (*GlUniformMatrix4fv) API @@ -15579,6 +22713,24 @@ func NewGlUniformMatrix4fv( func (c *GlUniformMatrix4fv) API() gfxapi.API ``` +#### func (*GlUniformMatrix4fv) AddRead + +```go +func (a *GlUniformMatrix4fv) AddRead(rng memory.Range, id binary.ID) *GlUniformMatrix4fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUniformMatrix4fv pointer is returned so that calls can be +chained. + +#### func (*GlUniformMatrix4fv) AddWrite + +```go +func (a *GlUniformMatrix4fv) AddWrite(rng memory.Range, id binary.ID) *GlUniformMatrix4fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUniformMatrix4fv pointer is returned so that calls can be +chained. + #### func (*GlUniformMatrix4fv) Class ```go @@ -15594,19 +22746,25 @@ func (c *GlUniformMatrix4fv) Flags() atom.Flags #### func (*GlUniformMatrix4fv) Mutate ```go -func (ϟa *GlUniformMatrix4fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUniformMatrix4fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUniformMatrix4fv) Observations + +```go +func (a *GlUniformMatrix4fv) Observations() *atom.Observations ``` #### func (*GlUniformMatrix4fv) Replay ```go -func (ϟa *GlUniformMatrix4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUniformMatrix4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUniformMatrix4fv) String ```go -func (c *GlUniformMatrix4fv) String() string +func (a *GlUniformMatrix4fv) String() string ``` #### func (*GlUniformMatrix4fv) TypeID @@ -15620,6 +22778,7 @@ func (c *GlUniformMatrix4fv) TypeID() atom.TypeID ```go type GlUnmapBuffer struct { binary.Generate + Target BufferTarget } ``` @@ -15631,9 +22790,7 @@ GlUnmapBuffer #### func NewGlUnmapBuffer ```go -func NewGlUnmapBuffer( - pTarget BufferTarget, -) *GlUnmapBuffer +func NewGlUnmapBuffer(Target BufferTarget) *GlUnmapBuffer ``` #### func (*GlUnmapBuffer) API @@ -15642,6 +22799,22 @@ func NewGlUnmapBuffer( func (c *GlUnmapBuffer) API() gfxapi.API ``` +#### func (*GlUnmapBuffer) AddRead + +```go +func (a *GlUnmapBuffer) AddRead(rng memory.Range, id binary.ID) *GlUnmapBuffer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUnmapBuffer pointer is returned so that calls can be chained. + +#### func (*GlUnmapBuffer) AddWrite + +```go +func (a *GlUnmapBuffer) AddWrite(rng memory.Range, id binary.ID) *GlUnmapBuffer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUnmapBuffer pointer is returned so that calls can be chained. + #### func (*GlUnmapBuffer) Class ```go @@ -15657,19 +22830,25 @@ func (c *GlUnmapBuffer) Flags() atom.Flags #### func (*GlUnmapBuffer) Mutate ```go -func (ϟa *GlUnmapBuffer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUnmapBuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUnmapBuffer) Observations + +```go +func (a *GlUnmapBuffer) Observations() *atom.Observations ``` #### func (*GlUnmapBuffer) Replay ```go -func (ϟa *GlUnmapBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUnmapBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUnmapBuffer) String ```go -func (c *GlUnmapBuffer) String() string +func (a *GlUnmapBuffer) String() string ``` #### func (*GlUnmapBuffer) TypeID @@ -15683,6 +22862,7 @@ func (c *GlUnmapBuffer) TypeID() atom.TypeID ```go type GlUseProgram struct { binary.Generate + Program ProgramId } ``` @@ -15694,9 +22874,7 @@ GlUseProgram #### func NewGlUseProgram ```go -func NewGlUseProgram( - pProgram ProgramId, -) *GlUseProgram +func NewGlUseProgram(Program ProgramId) *GlUseProgram ``` #### func (*GlUseProgram) API @@ -15705,6 +22883,22 @@ func NewGlUseProgram( func (c *GlUseProgram) API() gfxapi.API ``` +#### func (*GlUseProgram) AddRead + +```go +func (a *GlUseProgram) AddRead(rng memory.Range, id binary.ID) *GlUseProgram +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlUseProgram pointer is returned so that calls can be chained. + +#### func (*GlUseProgram) AddWrite + +```go +func (a *GlUseProgram) AddWrite(rng memory.Range, id binary.ID) *GlUseProgram +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlUseProgram pointer is returned so that calls can be chained. + #### func (*GlUseProgram) Class ```go @@ -15720,19 +22914,25 @@ func (c *GlUseProgram) Flags() atom.Flags #### func (*GlUseProgram) Mutate ```go -func (ϟa *GlUseProgram) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlUseProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlUseProgram) Observations + +```go +func (a *GlUseProgram) Observations() *atom.Observations ``` #### func (*GlUseProgram) Replay ```go -func (ϟa *GlUseProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlUseProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlUseProgram) String ```go -func (c *GlUseProgram) String() string +func (a *GlUseProgram) String() string ``` #### func (*GlUseProgram) TypeID @@ -15746,6 +22946,7 @@ func (c *GlUseProgram) TypeID() atom.TypeID ```go type GlValidateProgram struct { binary.Generate + Program ProgramId } ``` @@ -15757,9 +22958,7 @@ GlValidateProgram #### func NewGlValidateProgram ```go -func NewGlValidateProgram( - pProgram ProgramId, -) *GlValidateProgram +func NewGlValidateProgram(Program ProgramId) *GlValidateProgram ``` #### func (*GlValidateProgram) API @@ -15768,6 +22967,22 @@ func NewGlValidateProgram( func (c *GlValidateProgram) API() gfxapi.API ``` +#### func (*GlValidateProgram) AddRead + +```go +func (a *GlValidateProgram) AddRead(rng memory.Range, id binary.ID) *GlValidateProgram +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlValidateProgram pointer is returned so that calls can be chained. + +#### func (*GlValidateProgram) AddWrite + +```go +func (a *GlValidateProgram) AddWrite(rng memory.Range, id binary.ID) *GlValidateProgram +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlValidateProgram pointer is returned so that calls can be chained. + #### func (*GlValidateProgram) Class ```go @@ -15783,19 +22998,25 @@ func (c *GlValidateProgram) Flags() atom.Flags #### func (*GlValidateProgram) Mutate ```go -func (ϟa *GlValidateProgram) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlValidateProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlValidateProgram) Observations + +```go +func (a *GlValidateProgram) Observations() *atom.Observations ``` #### func (*GlValidateProgram) Replay ```go -func (ϟa *GlValidateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlValidateProgram) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlValidateProgram) String ```go -func (c *GlValidateProgram) String() string +func (a *GlValidateProgram) String() string ``` #### func (*GlValidateProgram) TypeID @@ -15809,6 +23030,7 @@ func (c *GlValidateProgram) TypeID() atom.TypeID ```go type GlVertexAttrib1f struct { binary.Generate + Location AttributeLocation Value0 float32 } @@ -15821,10 +23043,7 @@ GlVertexAttrib1f #### func NewGlVertexAttrib1f ```go -func NewGlVertexAttrib1f( - pLocation AttributeLocation, - pValue0 float32, -) *GlVertexAttrib1f +func NewGlVertexAttrib1f(Location AttributeLocation, Value0 float32) *GlVertexAttrib1f ``` #### func (*GlVertexAttrib1f) API @@ -15833,6 +23052,22 @@ func NewGlVertexAttrib1f( func (c *GlVertexAttrib1f) API() gfxapi.API ``` +#### func (*GlVertexAttrib1f) AddRead + +```go +func (a *GlVertexAttrib1f) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib1f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib1f pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib1f) AddWrite + +```go +func (a *GlVertexAttrib1f) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib1f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib1f pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib1f) Class ```go @@ -15848,19 +23083,25 @@ func (c *GlVertexAttrib1f) Flags() atom.Flags #### func (*GlVertexAttrib1f) Mutate ```go -func (ϟa *GlVertexAttrib1f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib1f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib1f) Observations + +```go +func (a *GlVertexAttrib1f) Observations() *atom.Observations ``` #### func (*GlVertexAttrib1f) Replay ```go -func (ϟa *GlVertexAttrib1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib1f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib1f) String ```go -func (c *GlVertexAttrib1f) String() string +func (a *GlVertexAttrib1f) String() string ``` #### func (*GlVertexAttrib1f) TypeID @@ -15874,8 +23115,9 @@ func (c *GlVertexAttrib1f) TypeID() atom.TypeID ```go type GlVertexAttrib1fv struct { binary.Generate + Location AttributeLocation - Value F32Array + Value F32ᵖ } ``` @@ -15886,10 +23128,7 @@ GlVertexAttrib1fv #### func NewGlVertexAttrib1fv ```go -func NewGlVertexAttrib1fv( - pLocation AttributeLocation, - pValue F32Array, -) *GlVertexAttrib1fv +func NewGlVertexAttrib1fv(Location AttributeLocation, Value memory.Pointer) *GlVertexAttrib1fv ``` #### func (*GlVertexAttrib1fv) API @@ -15898,6 +23137,22 @@ func NewGlVertexAttrib1fv( func (c *GlVertexAttrib1fv) API() gfxapi.API ``` +#### func (*GlVertexAttrib1fv) AddRead + +```go +func (a *GlVertexAttrib1fv) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib1fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib1fv pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib1fv) AddWrite + +```go +func (a *GlVertexAttrib1fv) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib1fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib1fv pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib1fv) Class ```go @@ -15913,19 +23168,25 @@ func (c *GlVertexAttrib1fv) Flags() atom.Flags #### func (*GlVertexAttrib1fv) Mutate ```go -func (ϟa *GlVertexAttrib1fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib1fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib1fv) Observations + +```go +func (a *GlVertexAttrib1fv) Observations() *atom.Observations ``` #### func (*GlVertexAttrib1fv) Replay ```go -func (ϟa *GlVertexAttrib1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib1fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib1fv) String ```go -func (c *GlVertexAttrib1fv) String() string +func (a *GlVertexAttrib1fv) String() string ``` #### func (*GlVertexAttrib1fv) TypeID @@ -15939,6 +23200,7 @@ func (c *GlVertexAttrib1fv) TypeID() atom.TypeID ```go type GlVertexAttrib2f struct { binary.Generate + Location AttributeLocation Value0 float32 Value1 float32 @@ -15952,11 +23214,7 @@ GlVertexAttrib2f #### func NewGlVertexAttrib2f ```go -func NewGlVertexAttrib2f( - pLocation AttributeLocation, - pValue0 float32, - pValue1 float32, -) *GlVertexAttrib2f +func NewGlVertexAttrib2f(Location AttributeLocation, Value0 float32, Value1 float32) *GlVertexAttrib2f ``` #### func (*GlVertexAttrib2f) API @@ -15965,6 +23223,22 @@ func NewGlVertexAttrib2f( func (c *GlVertexAttrib2f) API() gfxapi.API ``` +#### func (*GlVertexAttrib2f) AddRead + +```go +func (a *GlVertexAttrib2f) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib2f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib2f pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib2f) AddWrite + +```go +func (a *GlVertexAttrib2f) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib2f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib2f pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib2f) Class ```go @@ -15980,19 +23254,25 @@ func (c *GlVertexAttrib2f) Flags() atom.Flags #### func (*GlVertexAttrib2f) Mutate ```go -func (ϟa *GlVertexAttrib2f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib2f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib2f) Observations + +```go +func (a *GlVertexAttrib2f) Observations() *atom.Observations ``` #### func (*GlVertexAttrib2f) Replay ```go -func (ϟa *GlVertexAttrib2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib2f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib2f) String ```go -func (c *GlVertexAttrib2f) String() string +func (a *GlVertexAttrib2f) String() string ``` #### func (*GlVertexAttrib2f) TypeID @@ -16006,8 +23286,9 @@ func (c *GlVertexAttrib2f) TypeID() atom.TypeID ```go type GlVertexAttrib2fv struct { binary.Generate + Location AttributeLocation - Value F32Array + Value F32ᵖ } ``` @@ -16018,10 +23299,7 @@ GlVertexAttrib2fv #### func NewGlVertexAttrib2fv ```go -func NewGlVertexAttrib2fv( - pLocation AttributeLocation, - pValue F32Array, -) *GlVertexAttrib2fv +func NewGlVertexAttrib2fv(Location AttributeLocation, Value memory.Pointer) *GlVertexAttrib2fv ``` #### func (*GlVertexAttrib2fv) API @@ -16030,6 +23308,22 @@ func NewGlVertexAttrib2fv( func (c *GlVertexAttrib2fv) API() gfxapi.API ``` +#### func (*GlVertexAttrib2fv) AddRead + +```go +func (a *GlVertexAttrib2fv) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib2fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib2fv pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib2fv) AddWrite + +```go +func (a *GlVertexAttrib2fv) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib2fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib2fv pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib2fv) Class ```go @@ -16045,19 +23339,25 @@ func (c *GlVertexAttrib2fv) Flags() atom.Flags #### func (*GlVertexAttrib2fv) Mutate ```go -func (ϟa *GlVertexAttrib2fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib2fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib2fv) Observations + +```go +func (a *GlVertexAttrib2fv) Observations() *atom.Observations ``` #### func (*GlVertexAttrib2fv) Replay ```go -func (ϟa *GlVertexAttrib2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib2fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib2fv) String ```go -func (c *GlVertexAttrib2fv) String() string +func (a *GlVertexAttrib2fv) String() string ``` #### func (*GlVertexAttrib2fv) TypeID @@ -16071,6 +23371,7 @@ func (c *GlVertexAttrib2fv) TypeID() atom.TypeID ```go type GlVertexAttrib3f struct { binary.Generate + Location AttributeLocation Value0 float32 Value1 float32 @@ -16085,12 +23386,7 @@ GlVertexAttrib3f #### func NewGlVertexAttrib3f ```go -func NewGlVertexAttrib3f( - pLocation AttributeLocation, - pValue0 float32, - pValue1 float32, - pValue2 float32, -) *GlVertexAttrib3f +func NewGlVertexAttrib3f(Location AttributeLocation, Value0 float32, Value1 float32, Value2 float32) *GlVertexAttrib3f ``` #### func (*GlVertexAttrib3f) API @@ -16099,6 +23395,22 @@ func NewGlVertexAttrib3f( func (c *GlVertexAttrib3f) API() gfxapi.API ``` +#### func (*GlVertexAttrib3f) AddRead + +```go +func (a *GlVertexAttrib3f) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib3f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib3f pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib3f) AddWrite + +```go +func (a *GlVertexAttrib3f) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib3f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib3f pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib3f) Class ```go @@ -16114,19 +23426,25 @@ func (c *GlVertexAttrib3f) Flags() atom.Flags #### func (*GlVertexAttrib3f) Mutate ```go -func (ϟa *GlVertexAttrib3f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib3f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib3f) Observations + +```go +func (a *GlVertexAttrib3f) Observations() *atom.Observations ``` #### func (*GlVertexAttrib3f) Replay ```go -func (ϟa *GlVertexAttrib3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib3f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib3f) String ```go -func (c *GlVertexAttrib3f) String() string +func (a *GlVertexAttrib3f) String() string ``` #### func (*GlVertexAttrib3f) TypeID @@ -16140,8 +23458,9 @@ func (c *GlVertexAttrib3f) TypeID() atom.TypeID ```go type GlVertexAttrib3fv struct { binary.Generate + Location AttributeLocation - Value F32Array + Value F32ᵖ } ``` @@ -16152,10 +23471,7 @@ GlVertexAttrib3fv #### func NewGlVertexAttrib3fv ```go -func NewGlVertexAttrib3fv( - pLocation AttributeLocation, - pValue F32Array, -) *GlVertexAttrib3fv +func NewGlVertexAttrib3fv(Location AttributeLocation, Value memory.Pointer) *GlVertexAttrib3fv ``` #### func (*GlVertexAttrib3fv) API @@ -16164,6 +23480,22 @@ func NewGlVertexAttrib3fv( func (c *GlVertexAttrib3fv) API() gfxapi.API ``` +#### func (*GlVertexAttrib3fv) AddRead + +```go +func (a *GlVertexAttrib3fv) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib3fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib3fv pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib3fv) AddWrite + +```go +func (a *GlVertexAttrib3fv) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib3fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib3fv pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib3fv) Class ```go @@ -16179,19 +23511,25 @@ func (c *GlVertexAttrib3fv) Flags() atom.Flags #### func (*GlVertexAttrib3fv) Mutate ```go -func (ϟa *GlVertexAttrib3fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib3fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib3fv) Observations + +```go +func (a *GlVertexAttrib3fv) Observations() *atom.Observations ``` #### func (*GlVertexAttrib3fv) Replay ```go -func (ϟa *GlVertexAttrib3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib3fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib3fv) String ```go -func (c *GlVertexAttrib3fv) String() string +func (a *GlVertexAttrib3fv) String() string ``` #### func (*GlVertexAttrib3fv) TypeID @@ -16205,6 +23543,7 @@ func (c *GlVertexAttrib3fv) TypeID() atom.TypeID ```go type GlVertexAttrib4f struct { binary.Generate + Location AttributeLocation Value0 float32 Value1 float32 @@ -16220,13 +23559,7 @@ GlVertexAttrib4f #### func NewGlVertexAttrib4f ```go -func NewGlVertexAttrib4f( - pLocation AttributeLocation, - pValue0 float32, - pValue1 float32, - pValue2 float32, - pValue3 float32, -) *GlVertexAttrib4f +func NewGlVertexAttrib4f(Location AttributeLocation, Value0 float32, Value1 float32, Value2 float32, Value3 float32) *GlVertexAttrib4f ``` #### func (*GlVertexAttrib4f) API @@ -16235,6 +23568,22 @@ func NewGlVertexAttrib4f( func (c *GlVertexAttrib4f) API() gfxapi.API ``` +#### func (*GlVertexAttrib4f) AddRead + +```go +func (a *GlVertexAttrib4f) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib4f +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib4f pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib4f) AddWrite + +```go +func (a *GlVertexAttrib4f) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib4f +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib4f pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib4f) Class ```go @@ -16250,19 +23599,25 @@ func (c *GlVertexAttrib4f) Flags() atom.Flags #### func (*GlVertexAttrib4f) Mutate ```go -func (ϟa *GlVertexAttrib4f) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib4f) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib4f) Observations + +```go +func (a *GlVertexAttrib4f) Observations() *atom.Observations ``` #### func (*GlVertexAttrib4f) Replay ```go -func (ϟa *GlVertexAttrib4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib4f) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib4f) String ```go -func (c *GlVertexAttrib4f) String() string +func (a *GlVertexAttrib4f) String() string ``` #### func (*GlVertexAttrib4f) TypeID @@ -16276,8 +23631,9 @@ func (c *GlVertexAttrib4f) TypeID() atom.TypeID ```go type GlVertexAttrib4fv struct { binary.Generate + Location AttributeLocation - Value F32Array + Value F32ᵖ } ``` @@ -16288,10 +23644,7 @@ GlVertexAttrib4fv #### func NewGlVertexAttrib4fv ```go -func NewGlVertexAttrib4fv( - pLocation AttributeLocation, - pValue F32Array, -) *GlVertexAttrib4fv +func NewGlVertexAttrib4fv(Location AttributeLocation, Value memory.Pointer) *GlVertexAttrib4fv ``` #### func (*GlVertexAttrib4fv) API @@ -16300,6 +23653,22 @@ func NewGlVertexAttrib4fv( func (c *GlVertexAttrib4fv) API() gfxapi.API ``` +#### func (*GlVertexAttrib4fv) AddRead + +```go +func (a *GlVertexAttrib4fv) AddRead(rng memory.Range, id binary.ID) *GlVertexAttrib4fv +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttrib4fv pointer is returned so that calls can be chained. + +#### func (*GlVertexAttrib4fv) AddWrite + +```go +func (a *GlVertexAttrib4fv) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttrib4fv +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttrib4fv pointer is returned so that calls can be chained. + #### func (*GlVertexAttrib4fv) Class ```go @@ -16315,19 +23684,25 @@ func (c *GlVertexAttrib4fv) Flags() atom.Flags #### func (*GlVertexAttrib4fv) Mutate ```go -func (ϟa *GlVertexAttrib4fv) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttrib4fv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttrib4fv) Observations + +```go +func (a *GlVertexAttrib4fv) Observations() *atom.Observations ``` #### func (*GlVertexAttrib4fv) Replay ```go -func (ϟa *GlVertexAttrib4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttrib4fv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttrib4fv) String ```go -func (c *GlVertexAttrib4fv) String() string +func (a *GlVertexAttrib4fv) String() string ``` #### func (*GlVertexAttrib4fv) TypeID @@ -16341,6 +23716,7 @@ func (c *GlVertexAttrib4fv) TypeID() atom.TypeID ```go type GlVertexAttribPointer struct { binary.Generate + Location AttributeLocation Size int32 Type VertexAttribType @@ -16357,14 +23733,7 @@ GlVertexAttribPointer #### func NewGlVertexAttribPointer ```go -func NewGlVertexAttribPointer( - pLocation AttributeLocation, - pSize int32, - pType VertexAttribType, - pNormalized bool, - pStride int32, - pData VertexPointer, -) *GlVertexAttribPointer +func NewGlVertexAttribPointer(Location AttributeLocation, Size int32, Type VertexAttribType, Normalized bool, Stride int32, Data memory.Pointer) *GlVertexAttribPointer ``` #### func (*GlVertexAttribPointer) API @@ -16373,6 +23742,24 @@ func NewGlVertexAttribPointer( func (c *GlVertexAttribPointer) API() gfxapi.API ``` +#### func (*GlVertexAttribPointer) AddRead + +```go +func (a *GlVertexAttribPointer) AddRead(rng memory.Range, id binary.ID) *GlVertexAttribPointer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlVertexAttribPointer pointer is returned so that calls can be +chained. + +#### func (*GlVertexAttribPointer) AddWrite + +```go +func (a *GlVertexAttribPointer) AddWrite(rng memory.Range, id binary.ID) *GlVertexAttribPointer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlVertexAttribPointer pointer is returned so that calls can be +chained. + #### func (*GlVertexAttribPointer) Class ```go @@ -16388,19 +23775,25 @@ func (c *GlVertexAttribPointer) Flags() atom.Flags #### func (*GlVertexAttribPointer) Mutate ```go -func (ϟa *GlVertexAttribPointer) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlVertexAttribPointer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlVertexAttribPointer) Observations + +```go +func (a *GlVertexAttribPointer) Observations() *atom.Observations ``` #### func (*GlVertexAttribPointer) Replay ```go -func (ϟa *GlVertexAttribPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlVertexAttribPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlVertexAttribPointer) String ```go -func (c *GlVertexAttribPointer) String() string +func (a *GlVertexAttribPointer) String() string ``` #### func (*GlVertexAttribPointer) TypeID @@ -16414,6 +23807,7 @@ func (c *GlVertexAttribPointer) TypeID() atom.TypeID ```go type GlViewport struct { binary.Generate + X int32 Y int32 Width int32 @@ -16428,12 +23822,7 @@ GlViewport #### func NewGlViewport ```go -func NewGlViewport( - pX int32, - pY int32, - pWidth int32, - pHeight int32, -) *GlViewport +func NewGlViewport(X int32, Y int32, Width int32, Height int32) *GlViewport ``` #### func (*GlViewport) API @@ -16442,6 +23831,22 @@ func NewGlViewport( func (c *GlViewport) API() gfxapi.API ``` +#### func (*GlViewport) AddRead + +```go +func (a *GlViewport) AddRead(rng memory.Range, id binary.ID) *GlViewport +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlViewport pointer is returned so that calls can be chained. + +#### func (*GlViewport) AddWrite + +```go +func (a *GlViewport) AddWrite(rng memory.Range, id binary.ID) *GlViewport +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlViewport pointer is returned so that calls can be chained. + #### func (*GlViewport) Class ```go @@ -16457,19 +23862,25 @@ func (c *GlViewport) Flags() atom.Flags #### func (*GlViewport) Mutate ```go -func (ϟa *GlViewport) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlViewport) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlViewport) Observations + +```go +func (a *GlViewport) Observations() *atom.Observations ``` #### func (*GlViewport) Replay ```go -func (ϟa *GlViewport) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *GlViewport) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*GlViewport) String ```go -func (c *GlViewport) String() string +func (a *GlViewport) String() string ``` #### func (*GlViewport) TypeID @@ -16478,13 +23889,100 @@ func (c *GlViewport) String() string func (c *GlViewport) TypeID() atom.TypeID ``` +#### type GlWaitSync + +```go +type GlWaitSync struct { + binary.Generate + + Sync SyncObject + SyncFlags SyncFlags + Timeout uint64 +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlWaitSync +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlWaitSync + +```go +func NewGlWaitSync(Sync SyncObject, SyncFlags SyncFlags, Timeout uint64) *GlWaitSync +``` + +#### func (*GlWaitSync) API + +```go +func (c *GlWaitSync) API() gfxapi.API +``` + +#### func (*GlWaitSync) AddRead + +```go +func (a *GlWaitSync) AddRead(rng memory.Range, id binary.ID) *GlWaitSync +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlWaitSync pointer is returned so that calls can be chained. + +#### func (*GlWaitSync) AddWrite + +```go +func (a *GlWaitSync) AddWrite(rng memory.Range, id binary.ID) *GlWaitSync +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlWaitSync pointer is returned so that calls can be chained. + +#### func (*GlWaitSync) Class + +```go +func (*GlWaitSync) Class() binary.Class +``` + +#### func (*GlWaitSync) Flags + +```go +func (c *GlWaitSync) Flags() atom.Flags +``` + +#### func (*GlWaitSync) Mutate + +```go +func (ϟa *GlWaitSync) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlWaitSync) Observations + +```go +func (a *GlWaitSync) Observations() *atom.Observations +``` + +#### func (*GlWaitSync) Replay + +```go +func (ϟa *GlWaitSync) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*GlWaitSync) String + +```go +func (a *GlWaitSync) String() string +``` + +#### func (*GlWaitSync) TypeID + +```go +func (c *GlWaitSync) TypeID() atom.TypeID +``` + #### type GlXCreateContext ```go type GlXCreateContext struct { binary.Generate - Dpy memory.Pointer - Vis memory.Pointer + + Dpy Voidᵖ + Vis Voidᵖ ShareList GLXContext Direct bool Result GLXContext @@ -16498,13 +23996,7 @@ GlXCreateContext #### func NewGlXCreateContext ```go -func NewGlXCreateContext( - pDpy memory.Pointer, - pVis memory.Pointer, - pShareList GLXContext, - pDirect bool, - pResult GLXContext, -) *GlXCreateContext +func NewGlXCreateContext(Dpy memory.Pointer, Vis memory.Pointer, ShareList memory.Pointer, Direct bool, Result memory.Pointer) *GlXCreateContext ``` #### func (*GlXCreateContext) API @@ -16513,55 +24005,62 @@ func NewGlXCreateContext( func (c *GlXCreateContext) API() gfxapi.API ``` -#### func (*GlXCreateContext) Class +#### func (*GlXCreateContext) AddRead ```go -func (*GlXCreateContext) Class() binary.Class +func (a *GlXCreateContext) AddRead(rng memory.Range, id binary.ID) *GlXCreateContext ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXCreateContext pointer is returned so that calls can be chained. -#### func (*GlXCreateContext) Flags +#### func (*GlXCreateContext) AddWrite ```go -func (c *GlXCreateContext) Flags() atom.Flags +func (a *GlXCreateContext) AddWrite(rng memory.Range, id binary.ID) *GlXCreateContext ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXCreateContext pointer is returned so that calls can be chained. -#### func (*GlXCreateContext) Mutate +#### func (*GlXCreateContext) Class ```go -func (ϟa *GlXCreateContext) Mutate(ϟs *gfxapi.State) error +func (*GlXCreateContext) Class() binary.Class ``` -#### func (*GlXCreateContext) Replay +#### func (*GlXCreateContext) Flags ```go -func (ω *GlXCreateContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (c *GlXCreateContext) Flags() atom.Flags ``` -#### func (*GlXCreateContext) String +#### func (*GlXCreateContext) Mutate ```go -func (c *GlXCreateContext) String() string +func (ϟa *GlXCreateContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlXCreateContext) TypeID +#### func (*GlXCreateContext) Observations ```go -func (c *GlXCreateContext) TypeID() atom.TypeID +func (a *GlXCreateContext) Observations() *atom.Observations ``` -#### type GlXCreateContext_Postback +#### func (*GlXCreateContext) Replay ```go -type GlXCreateContext_Postback struct { - Result []byte -} +func (ω *GlXCreateContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` +#### func (*GlXCreateContext) String + +```go +func (a *GlXCreateContext) String() string +``` -#### func (*GlXCreateContext_Postback) Decode +#### func (*GlXCreateContext) TypeID ```go -func (o *GlXCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *GlXCreateContext) TypeID() atom.TypeID ``` #### type GlXCreateNewContext @@ -16569,8 +24068,9 @@ func (o *GlXCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) ```go type GlXCreateNewContext struct { binary.Generate - Display memory.Pointer - Fbconfig memory.Pointer + + Display Voidᵖ + Fbconfig Voidᵖ Type uint32 Shared GLXContext Direct bool @@ -16585,14 +24085,7 @@ GlXCreateNewContext #### func NewGlXCreateNewContext ```go -func NewGlXCreateNewContext( - pDisplay memory.Pointer, - pFbconfig memory.Pointer, - pType uint32, - pShared GLXContext, - pDirect bool, - pResult GLXContext, -) *GlXCreateNewContext +func NewGlXCreateNewContext(Display memory.Pointer, Fbconfig memory.Pointer, Type uint32, Shared memory.Pointer, Direct bool, Result memory.Pointer) *GlXCreateNewContext ``` #### func (*GlXCreateNewContext) API @@ -16601,55 +24094,64 @@ func NewGlXCreateNewContext( func (c *GlXCreateNewContext) API() gfxapi.API ``` -#### func (*GlXCreateNewContext) Class +#### func (*GlXCreateNewContext) AddRead ```go -func (*GlXCreateNewContext) Class() binary.Class +func (a *GlXCreateNewContext) AddRead(rng memory.Range, id binary.ID) *GlXCreateNewContext ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXCreateNewContext pointer is returned so that calls can be +chained. -#### func (*GlXCreateNewContext) Flags +#### func (*GlXCreateNewContext) AddWrite ```go -func (c *GlXCreateNewContext) Flags() atom.Flags +func (a *GlXCreateNewContext) AddWrite(rng memory.Range, id binary.ID) *GlXCreateNewContext ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXCreateNewContext pointer is returned so that calls can be +chained. -#### func (*GlXCreateNewContext) Mutate +#### func (*GlXCreateNewContext) Class ```go -func (ϟa *GlXCreateNewContext) Mutate(ϟs *gfxapi.State) error +func (*GlXCreateNewContext) Class() binary.Class ``` -#### func (*GlXCreateNewContext) Replay +#### func (*GlXCreateNewContext) Flags ```go -func (ω *GlXCreateNewContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (c *GlXCreateNewContext) Flags() atom.Flags ``` -#### func (*GlXCreateNewContext) String +#### func (*GlXCreateNewContext) Mutate ```go -func (c *GlXCreateNewContext) String() string +func (ϟa *GlXCreateNewContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*GlXCreateNewContext) TypeID +#### func (*GlXCreateNewContext) Observations ```go -func (c *GlXCreateNewContext) TypeID() atom.TypeID +func (a *GlXCreateNewContext) Observations() *atom.Observations ``` -#### type GlXCreateNewContext_Postback +#### func (*GlXCreateNewContext) Replay ```go -type GlXCreateNewContext_Postback struct { - Result []byte -} +func (ω *GlXCreateNewContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` +#### func (*GlXCreateNewContext) String -#### func (*GlXCreateNewContext_Postback) Decode +```go +func (a *GlXCreateNewContext) String() string +``` + +#### func (*GlXCreateNewContext) TypeID ```go -func (o *GlXCreateNewContext_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *GlXCreateNewContext) TypeID() atom.TypeID ``` #### type GlXMakeContextCurrent @@ -16657,10 +24159,12 @@ func (o *GlXCreateNewContext_Postback) Decode(result_cnt uint64, d binary.Decode ```go type GlXMakeContextCurrent struct { binary.Generate - Display memory.Pointer + + Display Voidᵖ Draw GLXDrawable Read GLXDrawable Ctx GLXContext + Result Bool } ``` @@ -16671,12 +24175,7 @@ GlXMakeContextCurrent #### func NewGlXMakeContextCurrent ```go -func NewGlXMakeContextCurrent( - pDisplay memory.Pointer, - pDraw GLXDrawable, - pRead GLXDrawable, - pCtx GLXContext, -) *GlXMakeContextCurrent +func NewGlXMakeContextCurrent(Display memory.Pointer, Draw memory.Pointer, Read memory.Pointer, Ctx memory.Pointer, Result Bool) *GlXMakeContextCurrent ``` #### func (*GlXMakeContextCurrent) API @@ -16685,6 +24184,24 @@ func NewGlXMakeContextCurrent( func (c *GlXMakeContextCurrent) API() gfxapi.API ``` +#### func (*GlXMakeContextCurrent) AddRead + +```go +func (a *GlXMakeContextCurrent) AddRead(rng memory.Range, id binary.ID) *GlXMakeContextCurrent +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXMakeContextCurrent pointer is returned so that calls can be +chained. + +#### func (*GlXMakeContextCurrent) AddWrite + +```go +func (a *GlXMakeContextCurrent) AddWrite(rng memory.Range, id binary.ID) *GlXMakeContextCurrent +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXMakeContextCurrent pointer is returned so that calls can be +chained. + #### func (*GlXMakeContextCurrent) Class ```go @@ -16700,19 +24217,25 @@ func (c *GlXMakeContextCurrent) Flags() atom.Flags #### func (*GlXMakeContextCurrent) Mutate ```go -func (ϟa *GlXMakeContextCurrent) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlXMakeContextCurrent) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlXMakeContextCurrent) Observations + +```go +func (a *GlXMakeContextCurrent) Observations() *atom.Observations ``` #### func (*GlXMakeContextCurrent) Replay ```go -func (ω *GlXMakeContextCurrent) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (ω *GlXMakeContextCurrent) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` #### func (*GlXMakeContextCurrent) String ```go -func (c *GlXMakeContextCurrent) String() string +func (a *GlXMakeContextCurrent) String() string ``` #### func (*GlXMakeContextCurrent) TypeID @@ -16721,12 +24244,176 @@ func (c *GlXMakeContextCurrent) String() string func (c *GlXMakeContextCurrent) TypeID() atom.TypeID ``` +#### type GlXMakeCurrent + +```go +type GlXMakeCurrent struct { + binary.Generate + + Display Voidᵖ + Drawable GLXDrawable + Ctx GLXContext + Result Bool +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlXMakeCurrent +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlXMakeCurrent + +```go +func NewGlXMakeCurrent(Display memory.Pointer, Drawable memory.Pointer, Ctx memory.Pointer, Result Bool) *GlXMakeCurrent +``` + +#### func (*GlXMakeCurrent) API + +```go +func (c *GlXMakeCurrent) API() gfxapi.API +``` + +#### func (*GlXMakeCurrent) AddRead + +```go +func (a *GlXMakeCurrent) AddRead(rng memory.Range, id binary.ID) *GlXMakeCurrent +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXMakeCurrent pointer is returned so that calls can be chained. + +#### func (*GlXMakeCurrent) AddWrite + +```go +func (a *GlXMakeCurrent) AddWrite(rng memory.Range, id binary.ID) *GlXMakeCurrent +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXMakeCurrent pointer is returned so that calls can be chained. + +#### func (*GlXMakeCurrent) Class + +```go +func (*GlXMakeCurrent) Class() binary.Class +``` + +#### func (*GlXMakeCurrent) Flags + +```go +func (c *GlXMakeCurrent) Flags() atom.Flags +``` + +#### func (*GlXMakeCurrent) Mutate + +```go +func (ϟa *GlXMakeCurrent) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlXMakeCurrent) Observations + +```go +func (a *GlXMakeCurrent) Observations() *atom.Observations +``` + +#### func (*GlXMakeCurrent) String + +```go +func (a *GlXMakeCurrent) String() string +``` + +#### func (*GlXMakeCurrent) TypeID + +```go +func (c *GlXMakeCurrent) TypeID() atom.TypeID +``` + +#### type GlXQueryDrawable + +```go +type GlXQueryDrawable struct { + binary.Generate + + Display Voidᵖ + Draw GLXDrawable + Attribute int64 + Value Intᵖ + Result int64 +} +``` + +////////////////////////////////////////////////////////////////////////////// +GlXQueryDrawable +////////////////////////////////////////////////////////////////////////////// + +#### func NewGlXQueryDrawable + +```go +func NewGlXQueryDrawable(Display memory.Pointer, Draw memory.Pointer, Attribute int64, Value memory.Pointer, Result int64) *GlXQueryDrawable +``` + +#### func (*GlXQueryDrawable) API + +```go +func (c *GlXQueryDrawable) API() gfxapi.API +``` + +#### func (*GlXQueryDrawable) AddRead + +```go +func (a *GlXQueryDrawable) AddRead(rng memory.Range, id binary.ID) *GlXQueryDrawable +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXQueryDrawable pointer is returned so that calls can be chained. + +#### func (*GlXQueryDrawable) AddWrite + +```go +func (a *GlXQueryDrawable) AddWrite(rng memory.Range, id binary.ID) *GlXQueryDrawable +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXQueryDrawable pointer is returned so that calls can be chained. + +#### func (*GlXQueryDrawable) Class + +```go +func (*GlXQueryDrawable) Class() binary.Class +``` + +#### func (*GlXQueryDrawable) Flags + +```go +func (c *GlXQueryDrawable) Flags() atom.Flags +``` + +#### func (*GlXQueryDrawable) Mutate + +```go +func (ϟa *GlXQueryDrawable) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlXQueryDrawable) Observations + +```go +func (a *GlXQueryDrawable) Observations() *atom.Observations +``` + +#### func (*GlXQueryDrawable) String + +```go +func (a *GlXQueryDrawable) String() string +``` + +#### func (*GlXQueryDrawable) TypeID + +```go +func (c *GlXQueryDrawable) TypeID() atom.TypeID +``` + #### type GlXSwapBuffers ```go type GlXSwapBuffers struct { binary.Generate - Display memory.Pointer + + Display Voidᵖ Drawable GLXDrawable } ``` @@ -16738,10 +24425,7 @@ GlXSwapBuffers #### func NewGlXSwapBuffers ```go -func NewGlXSwapBuffers( - pDisplay memory.Pointer, - pDrawable GLXDrawable, -) *GlXSwapBuffers +func NewGlXSwapBuffers(Display memory.Pointer, Drawable memory.Pointer) *GlXSwapBuffers ``` #### func (*GlXSwapBuffers) API @@ -16750,6 +24434,22 @@ func NewGlXSwapBuffers( func (c *GlXSwapBuffers) API() gfxapi.API ``` +#### func (*GlXSwapBuffers) AddRead + +```go +func (a *GlXSwapBuffers) AddRead(rng memory.Range, id binary.ID) *GlXSwapBuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The GlXSwapBuffers pointer is returned so that calls can be chained. + +#### func (*GlXSwapBuffers) AddWrite + +```go +func (a *GlXSwapBuffers) AddWrite(rng memory.Range, id binary.ID) *GlXSwapBuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The GlXSwapBuffers pointer is returned so that calls can be chained. + #### func (*GlXSwapBuffers) Class ```go @@ -16765,13 +24465,19 @@ func (c *GlXSwapBuffers) Flags() atom.Flags #### func (*GlXSwapBuffers) Mutate ```go -func (ϟa *GlXSwapBuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *GlXSwapBuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*GlXSwapBuffers) Observations + +```go +func (a *GlXSwapBuffers) Observations() *atom.Observations ``` #### func (*GlXSwapBuffers) String ```go -func (c *GlXSwapBuffers) String() string +func (a *GlXSwapBuffers) String() string ``` #### func (*GlXSwapBuffers) TypeID @@ -16787,11 +24493,11 @@ type Globals struct { binary.Generate NextContextID ContextID CurrentThread ThreadID - Contexts ContextPtr_ThreadIDMap - EGLContexts ContextPtr_EGLContextMap - GLXContexts ContextPtr_GLXContextMap - WGLContexts ContextPtr_HGLRCMap - CGLContexts ContextPtr_CGLContextObjMap + Contexts ThreadIDːContextʳᵐ + EGLContexts EGLContextːContextʳᵐ + GLXContexts GLXContextːContextʳᵐ + WGLContexts HGLRCːContextʳᵐ + CGLContexts CGLContextObjːContextʳᵐ } ``` @@ -16814,39 +24520,124 @@ func (g *Globals) Init() #### type HDC ```go -type HDC memory.Pointer +type HDC struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +HDC is a pointer to a void element. + +#### func NewHDC + +```go +func NewHDC(addr memory.Pointer) HDC +``` +NewHDC returns a HDC that points to addr in the application pool. + +#### func (*HDC) Class + +```go +func (*HDC) Class() binary.Class +``` -#### func (*HDC) Equal +#### func (HDC) ElementSize ```go -func (c *HDC) Equal(rhs HDC) bool +func (p HDC) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that HDC points to. -#### func (*HDC) Less +#### func (HDC) Slice ```go -func (c *HDC) Less(rhs HDC) bool +func (p HDC) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (HDC) String + +```go +func (p HDC) String() string +``` +String returns a string description of the HDC pointer. #### type HGLRC ```go -type HGLRC memory.Pointer +type HGLRC struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +HGLRC is a pointer to a void element. -#### func (*HGLRC) Equal +#### func NewHGLRC ```go -func (c *HGLRC) Equal(rhs HGLRC) bool +func NewHGLRC(addr memory.Pointer) HGLRC ``` +NewHGLRC returns a HGLRC that points to addr in the application pool. -#### func (*HGLRC) Less +#### func (*HGLRC) Class ```go -func (c *HGLRC) Less(rhs HGLRC) bool +func (*HGLRC) Class() binary.Class +``` + +#### func (HGLRC) ElementSize + +```go +func (p HGLRC) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that HGLRC points to. + +#### func (HGLRC) Slice + +```go +func (p HGLRC) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (HGLRC) String + +```go +func (p HGLRC) String() string +``` +String returns a string description of the HGLRC pointer. + +#### type HGLRCːContextʳᵐ + +```go +type HGLRCːContextʳᵐ map[HGLRC](*Context) +``` + + +#### func (HGLRCːContextʳᵐ) Contains + +```go +func (m HGLRCːContextʳᵐ) Contains(key HGLRC) bool +``` + +#### func (HGLRCːContextʳᵐ) Delete + +```go +func (m HGLRCːContextʳᵐ) Delete(key HGLRC) +``` + +#### func (HGLRCːContextʳᵐ) Get + +```go +func (m HGLRCːContextʳᵐ) Get(key HGLRC) *Context +``` + +#### func (HGLRCːContextʳᵐ) Range + +```go +func (m HGLRCːContextʳᵐ) Range() [](*Context) ``` #### type HintMode @@ -16859,6 +24650,12 @@ type HintMode uint32 enum HintMode ////////////////////////////////////////////////////////////////////////////// +#### func (*HintMode) Parse + +```go +func (v *HintMode) Parse(s string) error +``` + #### func (HintMode) String ```go @@ -16875,6 +24672,12 @@ type HintTarget uint32 enum HintTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*HintTarget) Parse + +```go +func (v *HintTarget) Parse(s string) error +``` + #### func (HintTarget) String ```go @@ -16889,7 +24692,7 @@ type Image struct { CreatedAt atom.ID Width int32 Height int32 - Data memory.Memory + Data U8ˢ Size uint32 Format ImageTexelFormat } @@ -16920,21 +24723,48 @@ func (c *Image) Init() #### type ImageOES ```go -type ImageOES memory.Pointer +type ImageOES struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +ImageOES is a pointer to a void element. + +#### func NewImageOES + +```go +func NewImageOES(addr memory.Pointer) ImageOES ``` +NewImageOES returns a ImageOES that points to addr in the application pool. +#### func (*ImageOES) Class -#### func (*ImageOES) Equal +```go +func (*ImageOES) Class() binary.Class +``` + +#### func (ImageOES) ElementSize ```go -func (c *ImageOES) Equal(rhs ImageOES) bool +func (p ImageOES) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that ImageOES points to. -#### func (*ImageOES) Less +#### func (ImageOES) Slice ```go -func (c *ImageOES) Less(rhs ImageOES) bool +func (p ImageOES) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (ImageOES) String + +```go +func (p ImageOES) String() string +``` +String returns a string description of the ImageOES pointer. #### type ImageTargetRenderbufferStorage @@ -16946,6 +24776,12 @@ type ImageTargetRenderbufferStorage uint32 enum ImageTargetRenderbufferStorage ////////////////////////////////////////////////////////////////////////////// +#### func (*ImageTargetRenderbufferStorage) Parse + +```go +func (v *ImageTargetRenderbufferStorage) Parse(s string) error +``` + #### func (ImageTargetRenderbufferStorage) String ```go @@ -16962,6 +24798,12 @@ type ImageTargetTexture uint32 enum ImageTargetTexture ////////////////////////////////////////////////////////////////////////////// +#### func (*ImageTargetTexture) Parse + +```go +func (v *ImageTargetTexture) Parse(s string) error +``` + #### func (ImageTargetTexture) String ```go @@ -16978,6 +24820,12 @@ type ImageTargetTexture_OES_EGL_image uint32 enum ImageTargetTexture_OES_EGL_image ////////////////////////////////////////////////////////////////////////////// +#### func (*ImageTargetTexture_OES_EGL_image) Parse + +```go +func (v *ImageTargetTexture_OES_EGL_image) Parse(s string) error +``` + #### func (ImageTargetTexture_OES_EGL_image) String ```go @@ -16994,6 +24842,12 @@ type ImageTargetTexture_OES_EGL_image_external uint32 enum ImageTargetTexture_OES_EGL_image_external ////////////////////////////////////////////////////////////////////////////// +#### func (*ImageTargetTexture_OES_EGL_image_external) Parse + +```go +func (v *ImageTargetTexture_OES_EGL_image_external) Parse(s string) error +``` + #### func (ImageTargetTexture_OES_EGL_image_external) String ```go @@ -17010,127 +24864,289 @@ type ImageTexelFormat uint32 enum ImageTexelFormat ////////////////////////////////////////////////////////////////////////////// +#### func (*ImageTexelFormat) Parse + +```go +func (v *ImageTexelFormat) Parse(s string) error +``` + #### func (ImageTexelFormat) String ```go func (v ImageTexelFormat) String() string ``` -#### type Image_CubeMapImageTargetMap +#### type IndexedBufferTarget ```go -type Image_CubeMapImageTargetMap map[CubeMapImageTarget]Image +type IndexedBufferTarget uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum IndexedBufferTarget +////////////////////////////////////////////////////////////////////////////// -#### func (Image_CubeMapImageTargetMap) Contains +#### func (*IndexedBufferTarget) Parse ```go -func (m Image_CubeMapImageTargetMap) Contains(key CubeMapImageTarget) bool +func (v *IndexedBufferTarget) Parse(s string) error ``` -#### func (Image_CubeMapImageTargetMap) Delete +#### func (IndexedBufferTarget) String ```go -func (m Image_CubeMapImageTargetMap) Delete(key CubeMapImageTarget) +func (v IndexedBufferTarget) String() string ``` -#### func (Image_CubeMapImageTargetMap) Get +#### type IndicesPointer ```go -func (m Image_CubeMapImageTargetMap) Get(key CubeMapImageTarget) Image +type IndicesPointer struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (Image_CubeMapImageTargetMap) Range +IndicesPointer is a pointer to a void element. + +#### func NewIndicesPointer + +```go +func NewIndicesPointer(addr memory.Pointer) IndicesPointer +``` +NewIndicesPointer returns a IndicesPointer that points to addr in the +application pool. + +#### func (*IndicesPointer) Class ```go -func (m Image_CubeMapImageTargetMap) Range() []Image +func (*IndicesPointer) Class() binary.Class ``` -#### type Image_s32Map +#### func (IndicesPointer) ElementSize ```go -type Image_s32Map map[int32]Image +func (p IndicesPointer) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that IndicesPointer points +to. + +#### func (IndicesPointer) Slice +```go +func (p IndicesPointer) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (Image_s32Map) Contains +#### func (IndicesPointer) String ```go -func (m Image_s32Map) Contains(key int32) bool +func (p IndicesPointer) String() string ``` +String returns a string description of the IndicesPointer pointer. -#### func (Image_s32Map) Delete +#### type IndicesType ```go -func (m Image_s32Map) Delete(key int32) +type IndicesType uint32 ``` -#### func (Image_s32Map) Get +////////////////////////////////////////////////////////////////////////////// +enum IndicesType +////////////////////////////////////////////////////////////////////////////// + +#### func (*IndicesType) Parse ```go -func (m Image_s32Map) Get(key int32) Image +func (v *IndicesType) Parse(s string) error ``` -#### func (Image_s32Map) Range +#### func (IndicesType) String ```go -func (m Image_s32Map) Range() []Image +func (v IndicesType) String() string ``` -#### type IndicesPointer +#### type Intˢ ```go -type IndicesPointer memory.Pointer +type Intˢ struct { + binary.Generate + SliceInfo +} ``` +Intˢ is a slice of int64. -#### func (*IndicesPointer) Equal +#### func AsIntˢ ```go -func (c *IndicesPointer) Equal(rhs IndicesPointer) bool +func AsIntˢ(s Slice, ϟs *gfxapi.State) Intˢ ``` +AsIntˢ returns s cast to a Intˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. -#### func (*IndicesPointer) Less +#### func MakeIntˢ ```go -func (c *IndicesPointer) Less(rhs IndicesPointer) bool +func MakeIntˢ(count uint64, ϟs *gfxapi.State) Intˢ ``` +MakeIntˢ returns a Intˢ backed by a new memory pool. -#### type IndicesType +#### func (*Intˢ) Class ```go -type IndicesType uint32 +func (*Intˢ) Class() binary.Class ``` -////////////////////////////////////////////////////////////////////////////// -enum IndicesType -////////////////////////////////////////////////////////////////////////////// +#### func (Intˢ) Clone -#### func (IndicesType) String +```go +func (s Intˢ) Clone(ϟs *gfxapi.State) Intˢ +``` +Clone returns a copy of the Intˢ in a new memory pool. + +#### func (Intˢ) Copy ```go -func (v IndicesType) String() string +func (dst Intˢ) Copy(src Intˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Intˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Intˢ) Decoder + +```go +func (s Intˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Intˢ) ElementSize + +```go +func (s Intˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Intˢ points to. -#### type IntArray +#### func (Intˢ) Encoder ```go -type IntArray []int64 +func (s Intˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. +#### func (Intˢ) Index -#### func (IntArray) Len +```go +func (s Intˢ) Index(i uint64, ϟs *gfxapi.State) Intᵖ +``` +Index returns a Intᵖ to the i'th element in this Intˢ. + +#### func (Intˢ) Range ```go -func (s IntArray) Len() int +func (s Intˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### func (IntArray) Range +#### func (Intˢ) Read ```go -func (s IntArray) Range() []int64 +func (s Intˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int64 ``` +Read reads and returns all the int64 elements in this Intˢ. + +#### func (Intˢ) ResourceID + +```go +func (s Intˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Intˢ) Slice + +```go +func (s Intˢ) Slice(start, end uint64, ϟs *gfxapi.State) Intˢ +``` +Slice returns a sub-slice from the Intˢ using start and end indices. + +#### func (Intˢ) String + +```go +func (s Intˢ) String() string +``` +String returns a string description of the Intˢ slice. + +#### func (Intˢ) Write + +```go +func (dst Intˢ) Write(src []int64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Intᵖ + +```go +type Intᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Intᵖ is a pointer to a int64 element. + +#### func NewIntᵖ + +```go +func NewIntᵖ(addr memory.Pointer) Intᵖ +``` +NewIntᵖ returns a Intᵖ that points to addr in the application pool. + +#### func (*Intᵖ) Class + +```go +func (*Intᵖ) Class() binary.Class +``` + +#### func (Intᵖ) ElementSize + +```go +func (p Intᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Intᵖ points to. + +#### func (Intᵖ) Read + +```go +func (p Intᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int64 +``` +Read reads and returns the int64 element at the pointer. + +#### func (Intᵖ) Slice + +```go +func (p Intᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Intˢ +``` +Slice returns a new Intˢ from the pointer using start and end indices. + +#### func (Intᵖ) String + +```go +func (p Intᵖ) String() string +``` +String returns a string description of the Intᵖ pointer. + +#### func (Intᵖ) Write + +```go +func (p Intᵖ) Write(value int64, ϟs *gfxapi.State) +``` +Write writes value to the int64 element at the pointer. #### type MapBufferRangeAccess @@ -17142,6 +25158,12 @@ type MapBufferRangeAccess uint32 enum MapBufferRangeAccess ////////////////////////////////////////////////////////////////////////////// +#### func (*MapBufferRangeAccess) Parse + +```go +func (v *MapBufferRangeAccess) Parse(s string) error +``` + #### func (MapBufferRangeAccess) String ```go @@ -17151,17 +25173,9 @@ func (v MapBufferRangeAccess) String() string #### type Mat2f ```go -type Mat2f struct { - binary.Generate - CreatedAt atom.ID - Col0 Vec2f - Col1 Vec2f -} +type Mat2f Vec2fː2ᵃ ``` -////////////////////////////////////////////////////////////////////////////// -class Mat2f -////////////////////////////////////////////////////////////////////////////// #### func (*Mat2f) Class @@ -17169,56 +25183,203 @@ class Mat2f func (*Mat2f) Class() binary.Class ``` -#### func (*Mat2f) GetCreatedAt +#### func (Mat2f) String + +```go +func (m Mat2f) String() string +``` + +#### type Mat2fˢ ```go -func (c *Mat2f) GetCreatedAt() atom.ID +type Mat2fˢ struct { + binary.Generate + SliceInfo +} ``` -#### func (*Mat2f) Init +Mat2fˢ is a slice of Mat2f. + +#### func AsMat2fˢ ```go -func (c *Mat2f) Init() +func AsMat2fˢ(s Slice, ϟs *gfxapi.State) Mat2fˢ ``` +AsMat2fˢ returns s cast to a Mat2fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### func (Mat2f) String +#### func MakeMat2fˢ ```go -func (m Mat2f) String() string +func MakeMat2fˢ(count uint64, ϟs *gfxapi.State) Mat2fˢ ``` +MakeMat2fˢ returns a Mat2fˢ backed by a new memory pool. -#### type Mat3f +#### func (*Mat2fˢ) Class + +```go +func (*Mat2fˢ) Class() binary.Class +``` + +#### func (Mat2fˢ) Clone + +```go +func (s Mat2fˢ) Clone(ϟs *gfxapi.State) Mat2fˢ +``` +Clone returns a copy of the Mat2fˢ in a new memory pool. + +#### func (Mat2fˢ) Copy + +```go +func (dst Mat2fˢ) Copy(src Mat2fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Mat2fˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Mat2fˢ) Decoder + +```go +func (s Mat2fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Mat2fˢ) ElementSize + +```go +func (s Mat2fˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat2fˢ points to. + +#### func (Mat2fˢ) Encoder + +```go +func (s Mat2fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Mat2fˢ) Index + +```go +func (s Mat2fˢ) Index(i uint64, ϟs *gfxapi.State) Mat2fᵖ +``` +Index returns a Mat2fᵖ to the i'th element in this Mat2fˢ. + +#### func (Mat2fˢ) Range + +```go +func (s Mat2fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Mat2fˢ) Read + +```go +func (s Mat2fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Mat2f +``` +Read reads and returns all the Mat2f elements in this Mat2fˢ. + +#### func (Mat2fˢ) ResourceID + +```go +func (s Mat2fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Mat2fˢ) Slice + +```go +func (s Mat2fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Mat2fˢ +``` +Slice returns a sub-slice from the Mat2fˢ using start and end indices. + +#### func (Mat2fˢ) String + +```go +func (s Mat2fˢ) String() string +``` +String returns a string description of the Mat2fˢ slice. + +#### func (Mat2fˢ) Write + +```go +func (dst Mat2fˢ) Write(src []Mat2f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Mat2fᵖ ```go -type Mat3f struct { +type Mat2fᵖ struct { binary.Generate - CreatedAt atom.ID - Col0 Vec3f - Col1 Vec3f - Col2 Vec3f + Address memory.Pointer + Pool memory.PoolID } ``` -////////////////////////////////////////////////////////////////////////////// -class Mat3f -////////////////////////////////////////////////////////////////////////////// +Mat2fᵖ is a pointer to a Mat2f element. -#### func (*Mat3f) Class +#### func NewMat2fᵖ ```go -func (*Mat3f) Class() binary.Class +func NewMat2fᵖ(addr memory.Pointer) Mat2fᵖ +``` +NewMat2fᵖ returns a Mat2fᵖ that points to addr in the application pool. + +#### func (*Mat2fᵖ) Class + +```go +func (*Mat2fᵖ) Class() binary.Class +``` + +#### func (Mat2fᵖ) ElementSize + +```go +func (p Mat2fᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat2fᵖ points to. + +#### func (Mat2fᵖ) Read + +```go +func (p Mat2fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Mat2f ``` +Read reads and returns the Mat2f element at the pointer. -#### func (*Mat3f) GetCreatedAt +#### func (Mat2fᵖ) Slice ```go -func (c *Mat3f) GetCreatedAt() atom.ID +func (p Mat2fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Mat2fˢ ``` +Slice returns a new Mat2fˢ from the pointer using start and end indices. -#### func (*Mat3f) Init +#### func (Mat2fᵖ) String ```go -func (c *Mat3f) Init() +func (p Mat2fᵖ) String() string +``` +String returns a string description of the Mat2fᵖ pointer. + +#### func (Mat2fᵖ) Write + +```go +func (p Mat2fᵖ) Write(value Mat2f, ϟs *gfxapi.State) +``` +Write writes value to the Mat2f element at the pointer. + +#### type Mat3f + +```go +type Mat3f Vec3fː3ᵃ +``` + + +#### func (*Mat3f) Class + +```go +func (*Mat3f) Class() binary.Class ``` #### func (Mat3f) String @@ -17227,39 +25388,197 @@ func (c *Mat3f) Init() func (m Mat3f) String() string ``` -#### type Mat4f +#### type Mat3fˢ ```go -type Mat4f struct { +type Mat3fˢ struct { binary.Generate - CreatedAt atom.ID - Col0 Vec4f - Col1 Vec4f - Col2 Vec4f - Col3 Vec4f + SliceInfo } ``` -////////////////////////////////////////////////////////////////////////////// -class Mat4f -////////////////////////////////////////////////////////////////////////////// +Mat3fˢ is a slice of Mat3f. -#### func (*Mat4f) Class +#### func AsMat3fˢ ```go -func (*Mat4f) Class() binary.Class +func AsMat3fˢ(s Slice, ϟs *gfxapi.State) Mat3fˢ +``` +AsMat3fˢ returns s cast to a Mat3fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeMat3fˢ + +```go +func MakeMat3fˢ(count uint64, ϟs *gfxapi.State) Mat3fˢ +``` +MakeMat3fˢ returns a Mat3fˢ backed by a new memory pool. + +#### func (*Mat3fˢ) Class + +```go +func (*Mat3fˢ) Class() binary.Class +``` + +#### func (Mat3fˢ) Clone + +```go +func (s Mat3fˢ) Clone(ϟs *gfxapi.State) Mat3fˢ +``` +Clone returns a copy of the Mat3fˢ in a new memory pool. + +#### func (Mat3fˢ) Copy + +```go +func (dst Mat3fˢ) Copy(src Mat3fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Mat3fˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Mat3fˢ) Decoder + +```go +func (s Mat3fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Mat3fˢ) ElementSize + +```go +func (s Mat3fˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat3fˢ points to. + +#### func (Mat3fˢ) Encoder + +```go +func (s Mat3fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Mat3fˢ) Index + +```go +func (s Mat3fˢ) Index(i uint64, ϟs *gfxapi.State) Mat3fᵖ +``` +Index returns a Mat3fᵖ to the i'th element in this Mat3fˢ. + +#### func (Mat3fˢ) Range + +```go +func (s Mat3fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Mat3fˢ) Read + +```go +func (s Mat3fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Mat3f ``` +Read reads and returns all the Mat3f elements in this Mat3fˢ. -#### func (*Mat4f) GetCreatedAt +#### func (Mat3fˢ) ResourceID ```go -func (c *Mat4f) GetCreatedAt() atom.ID +func (s Mat3fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### func (*Mat4f) Init +#### func (Mat3fˢ) Slice ```go -func (c *Mat4f) Init() +func (s Mat3fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Mat3fˢ +``` +Slice returns a sub-slice from the Mat3fˢ using start and end indices. + +#### func (Mat3fˢ) String + +```go +func (s Mat3fˢ) String() string +``` +String returns a string description of the Mat3fˢ slice. + +#### func (Mat3fˢ) Write + +```go +func (dst Mat3fˢ) Write(src []Mat3f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Mat3fᵖ + +```go +type Mat3fᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Mat3fᵖ is a pointer to a Mat3f element. + +#### func NewMat3fᵖ + +```go +func NewMat3fᵖ(addr memory.Pointer) Mat3fᵖ +``` +NewMat3fᵖ returns a Mat3fᵖ that points to addr in the application pool. + +#### func (*Mat3fᵖ) Class + +```go +func (*Mat3fᵖ) Class() binary.Class +``` + +#### func (Mat3fᵖ) ElementSize + +```go +func (p Mat3fᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat3fᵖ points to. + +#### func (Mat3fᵖ) Read + +```go +func (p Mat3fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Mat3f +``` +Read reads and returns the Mat3f element at the pointer. + +#### func (Mat3fᵖ) Slice + +```go +func (p Mat3fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Mat3fˢ +``` +Slice returns a new Mat3fˢ from the pointer using start and end indices. + +#### func (Mat3fᵖ) String + +```go +func (p Mat3fᵖ) String() string +``` +String returns a string description of the Mat3fᵖ pointer. + +#### func (Mat3fᵖ) Write + +```go +func (p Mat3fᵖ) Write(value Mat3f, ϟs *gfxapi.State) +``` +Write writes value to the Mat3f element at the pointer. + +#### type Mat4f + +```go +type Mat4f Vec4fː4ᵃ +``` + + +#### func (*Mat4f) Class + +```go +func (*Mat4f) Class() binary.Class ``` #### func (Mat4f) String @@ -17268,20 +25587,200 @@ func (c *Mat4f) Init() func (m Mat4f) String() string ``` +#### type Mat4fˢ + +```go +type Mat4fˢ struct { + binary.Generate + SliceInfo +} +``` + +Mat4fˢ is a slice of Mat4f. + +#### func AsMat4fˢ + +```go +func AsMat4fˢ(s Slice, ϟs *gfxapi.State) Mat4fˢ +``` +AsMat4fˢ returns s cast to a Mat4fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeMat4fˢ + +```go +func MakeMat4fˢ(count uint64, ϟs *gfxapi.State) Mat4fˢ +``` +MakeMat4fˢ returns a Mat4fˢ backed by a new memory pool. + +#### func (*Mat4fˢ) Class + +```go +func (*Mat4fˢ) Class() binary.Class +``` + +#### func (Mat4fˢ) Clone + +```go +func (s Mat4fˢ) Clone(ϟs *gfxapi.State) Mat4fˢ +``` +Clone returns a copy of the Mat4fˢ in a new memory pool. + +#### func (Mat4fˢ) Copy + +```go +func (dst Mat4fˢ) Copy(src Mat4fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Mat4fˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Mat4fˢ) Decoder + +```go +func (s Mat4fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Mat4fˢ) ElementSize + +```go +func (s Mat4fˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat4fˢ points to. + +#### func (Mat4fˢ) Encoder + +```go +func (s Mat4fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Mat4fˢ) Index + +```go +func (s Mat4fˢ) Index(i uint64, ϟs *gfxapi.State) Mat4fᵖ +``` +Index returns a Mat4fᵖ to the i'th element in this Mat4fˢ. + +#### func (Mat4fˢ) Range + +```go +func (s Mat4fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Mat4fˢ) Read + +```go +func (s Mat4fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Mat4f +``` +Read reads and returns all the Mat4f elements in this Mat4fˢ. + +#### func (Mat4fˢ) ResourceID + +```go +func (s Mat4fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Mat4fˢ) Slice + +```go +func (s Mat4fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Mat4fˢ +``` +Slice returns a sub-slice from the Mat4fˢ using start and end indices. + +#### func (Mat4fˢ) String + +```go +func (s Mat4fˢ) String() string +``` +String returns a string description of the Mat4fˢ slice. + +#### func (Mat4fˢ) Write + +```go +func (dst Mat4fˢ) Write(src []Mat4f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Mat4fᵖ + +```go +type Mat4fᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Mat4fᵖ is a pointer to a Mat4f element. + +#### func NewMat4fᵖ + +```go +func NewMat4fᵖ(addr memory.Pointer) Mat4fᵖ +``` +NewMat4fᵖ returns a Mat4fᵖ that points to addr in the application pool. + +#### func (*Mat4fᵖ) Class + +```go +func (*Mat4fᵖ) Class() binary.Class +``` + +#### func (Mat4fᵖ) ElementSize + +```go +func (p Mat4fᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Mat4fᵖ points to. + +#### func (Mat4fᵖ) Read + +```go +func (p Mat4fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Mat4f +``` +Read reads and returns the Mat4f element at the pointer. + +#### func (Mat4fᵖ) Slice + +```go +func (p Mat4fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Mat4fˢ +``` +Slice returns a new Mat4fˢ from the pointer using start and end indices. + +#### func (Mat4fᵖ) String + +```go +func (p Mat4fᵖ) String() string +``` +String returns a string description of the Mat4fᵖ pointer. + +#### func (Mat4fᵖ) Write + +```go +func (p Mat4fᵖ) Write(value Mat4f, ϟs *gfxapi.State) +``` +Write writes value to the Mat4f element at the pointer. + #### type Objects ```go type Objects struct { binary.Generate CreatedAt atom.ID - Renderbuffers RenderbufferPtr_RenderbufferIdMap - Textures TexturePtr_TextureIdMap - Framebuffers FramebufferPtr_FramebufferIdMap - Buffers BufferPtr_BufferIdMap - Shaders ShaderPtr_ShaderIdMap - Programs ProgramPtr_ProgramIdMap - VertexArrays VertexArrayPtr_VertexArrayIdMap - Queries QueryPtr_QueryIdMap + Renderbuffers RenderbufferIdːRenderbufferʳᵐ + Textures TextureIdːTextureʳᵐ + Framebuffers FramebufferIdːFramebufferʳᵐ + Buffers BufferIdːBufferʳᵐ + Shaders ShaderIdːShaderʳᵐ + Programs ProgramIdːProgramʳᵐ + VertexArrays VertexArrayIdːVertexArrayʳᵐ + Queries QueryIdːQueryʳᵐ } ``` @@ -17317,12 +25816,49 @@ type PixelStoreParameter uint32 enum PixelStoreParameter ////////////////////////////////////////////////////////////////////////////// +#### func (*PixelStoreParameter) Parse + +```go +func (v *PixelStoreParameter) Parse(s string) error +``` + #### func (PixelStoreParameter) String ```go func (v PixelStoreParameter) String() string ``` +#### type PixelStoreParameterːs32ᵐ + +```go +type PixelStoreParameterːs32ᵐ map[PixelStoreParameter]int32 +``` + + +#### func (PixelStoreParameterːs32ᵐ) Contains + +```go +func (m PixelStoreParameterːs32ᵐ) Contains(key PixelStoreParameter) bool +``` + +#### func (PixelStoreParameterːs32ᵐ) Delete + +```go +func (m PixelStoreParameterːs32ᵐ) Delete(key PixelStoreParameter) +``` + +#### func (PixelStoreParameterːs32ᵐ) Get + +```go +func (m PixelStoreParameterːs32ᵐ) Get(key PixelStoreParameter) int32 +``` + +#### func (PixelStoreParameterːs32ᵐ) Range + +```go +func (m PixelStoreParameterːs32ᵐ) Range() []int32 +``` + #### type PrecisionType ```go @@ -17333,6 +25869,12 @@ type PrecisionType uint32 enum PrecisionType ////////////////////////////////////////////////////////////////////////////// +#### func (*PrecisionType) Parse + +```go +func (v *PrecisionType) Parse(s string) error +``` + #### func (PrecisionType) String ```go @@ -17345,13 +25887,13 @@ func (v PrecisionType) String() string type Program struct { binary.Generate CreatedAt atom.ID - Shaders ShaderId_ShaderTypeMap + Shaders ShaderTypeːShaderIdᵐ Linked bool - Binary memory.Memory - AttributeBindings AttributeLocation_CharBufferMap - Attributes VertexAttribute_s32Map - Uniforms Uniform_UniformLocationMap - InfoLog string + Binary U8ˢ + AttributeBindings StringːAttributeLocationᵐ + Attributes S32ːVertexAttributeᵐ + Uniforms UniformLocationːUniformᵐ + InfoLog Charˢ } ``` @@ -17377,42 +25919,42 @@ func (c *Program) GetCreatedAt() atom.ID func (c *Program) Init() ``` -#### type ProgramArray +#### type ProgramId ```go -type ProgramArray []Program +type ProgramId uint32 ``` -#### func (ProgramArray) Len +#### type ProgramIdːProgramʳᵐ ```go -func (s ProgramArray) Len() int +type ProgramIdːProgramʳᵐ map[ProgramId](*Program) ``` -#### func (ProgramArray) Range + +#### func (ProgramIdːProgramʳᵐ) Contains ```go -func (s ProgramArray) Range() []Program +func (m ProgramIdːProgramʳᵐ) Contains(key ProgramId) bool ``` -#### type ProgramId +#### func (ProgramIdːProgramʳᵐ) Delete ```go -type ProgramId uint32 +func (m ProgramIdːProgramʳᵐ) Delete(key ProgramId) ``` - -#### func (*ProgramId) Equal +#### func (ProgramIdːProgramʳᵐ) Get ```go -func (c *ProgramId) Equal(rhs ProgramId) bool +func (m ProgramIdːProgramʳᵐ) Get(key ProgramId) *Program ``` -#### func (*ProgramId) Less +#### func (ProgramIdːProgramʳᵐ) Range ```go -func (c *ProgramId) Less(rhs ProgramId) bool +func (m ProgramIdːProgramʳᵐ) Range() [](*Program) ``` #### type ProgramParameter @@ -17425,131 +25967,267 @@ type ProgramParameter uint32 enum ProgramParameter ////////////////////////////////////////////////////////////////////////////// +#### func (*ProgramParameter) Parse + +```go +func (v *ProgramParameter) Parse(s string) error +``` + #### func (ProgramParameter) String ```go func (v ProgramParameter) String() string ``` -#### type ProgramPtr_ProgramIdMap +#### type Query ```go -type ProgramPtr_ProgramIdMap map[ProgramId]*Program +type Query struct { + binary.Generate + CreatedAt atom.ID +} ``` +////////////////////////////////////////////////////////////////////////////// +class Query +////////////////////////////////////////////////////////////////////////////// -#### func (ProgramPtr_ProgramIdMap) Contains +#### func (*Query) Class ```go -func (m ProgramPtr_ProgramIdMap) Contains(key ProgramId) bool +func (*Query) Class() binary.Class ``` -#### func (ProgramPtr_ProgramIdMap) Delete +#### func (*Query) GetCreatedAt ```go -func (m ProgramPtr_ProgramIdMap) Delete(key ProgramId) +func (c *Query) GetCreatedAt() atom.ID ``` -#### func (ProgramPtr_ProgramIdMap) Get +#### func (*Query) Init ```go -func (m ProgramPtr_ProgramIdMap) Get(key ProgramId) *Program +func (c *Query) Init() ``` -#### func (ProgramPtr_ProgramIdMap) Range +#### type QueryId ```go -func (m ProgramPtr_ProgramIdMap) Range() []*Program +type QueryId uint32 ``` -#### type Query + +#### type QueryIdːQueryʳᵐ ```go -type Query struct { +type QueryIdːQueryʳᵐ map[QueryId](*Query) +``` + + +#### func (QueryIdːQueryʳᵐ) Contains + +```go +func (m QueryIdːQueryʳᵐ) Contains(key QueryId) bool +``` + +#### func (QueryIdːQueryʳᵐ) Delete + +```go +func (m QueryIdːQueryʳᵐ) Delete(key QueryId) +``` + +#### func (QueryIdːQueryʳᵐ) Get + +```go +func (m QueryIdːQueryʳᵐ) Get(key QueryId) *Query +``` + +#### func (QueryIdːQueryʳᵐ) Range + +```go +func (m QueryIdːQueryʳᵐ) Range() [](*Query) +``` + +#### type QueryIdˢ + +```go +type QueryIdˢ struct { binary.Generate - CreatedAt atom.ID + SliceInfo } ``` -////////////////////////////////////////////////////////////////////////////// -class Query -////////////////////////////////////////////////////////////////////////////// +QueryIdˢ is a slice of QueryId. -#### func (*Query) Class +#### func AsQueryIdˢ ```go -func (*Query) Class() binary.Class +func AsQueryIdˢ(s Slice, ϟs *gfxapi.State) QueryIdˢ ``` +AsQueryIdˢ returns s cast to a QueryIdˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### func (*Query) GetCreatedAt +#### func MakeQueryIdˢ ```go -func (c *Query) GetCreatedAt() atom.ID +func MakeQueryIdˢ(count uint64, ϟs *gfxapi.State) QueryIdˢ ``` +MakeQueryIdˢ returns a QueryIdˢ backed by a new memory pool. -#### func (*Query) Init +#### func (*QueryIdˢ) Class ```go -func (c *Query) Init() +func (*QueryIdˢ) Class() binary.Class +``` + +#### func (QueryIdˢ) Clone + +```go +func (s QueryIdˢ) Clone(ϟs *gfxapi.State) QueryIdˢ ``` +Clone returns a copy of the QueryIdˢ in a new memory pool. -#### type QueryArray +#### func (QueryIdˢ) Copy ```go -type QueryArray []Query +func (dst QueryIdˢ) Copy(src QueryIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s QueryIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (QueryIdˢ) Decoder +```go +func (s QueryIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. -#### func (QueryArray) Len +#### func (QueryIdˢ) ElementSize ```go -func (s QueryArray) Len() int +func (s QueryIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that QueryIdˢ points to. -#### func (QueryArray) Range +#### func (QueryIdˢ) Encoder ```go -func (s QueryArray) Range() []Query +func (s QueryIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### type QueryId +#### func (QueryIdˢ) Index ```go -type QueryId uint32 +func (s QueryIdˢ) Index(i uint64, ϟs *gfxapi.State) QueryIdᵖ ``` +Index returns a QueryIdᵖ to the i'th element in this QueryIdˢ. +#### func (QueryIdˢ) Range -#### func (*QueryId) Equal +```go +func (s QueryIdˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (QueryIdˢ) Read ```go -func (c *QueryId) Equal(rhs QueryId) bool +func (s QueryIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []QueryId ``` +Read reads and returns all the QueryId elements in this QueryIdˢ. -#### func (*QueryId) Less +#### func (QueryIdˢ) ResourceID ```go -func (c *QueryId) Less(rhs QueryId) bool +func (s QueryIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### type QueryIdArray +#### func (QueryIdˢ) Slice ```go -type QueryIdArray []QueryId +func (s QueryIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) QueryIdˢ ``` +Slice returns a sub-slice from the QueryIdˢ using start and end indices. + +#### func (QueryIdˢ) String +```go +func (s QueryIdˢ) String() string +``` +String returns a string description of the QueryIdˢ slice. -#### func (QueryIdArray) Len +#### func (QueryIdˢ) Write ```go -func (s QueryIdArray) Len() int +func (dst QueryIdˢ) Write(src []QueryId, ϟs *gfxapi.State) uint64 ``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### func (QueryIdArray) Range +#### type QueryIdᵖ ```go -func (s QueryIdArray) Range() []QueryId +type QueryIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +QueryIdᵖ is a pointer to a QueryId element. + +#### func NewQueryIdᵖ + +```go +func NewQueryIdᵖ(addr memory.Pointer) QueryIdᵖ +``` +NewQueryIdᵖ returns a QueryIdᵖ that points to addr in the application pool. + +#### func (*QueryIdᵖ) Class + +```go +func (*QueryIdᵖ) Class() binary.Class +``` + +#### func (QueryIdᵖ) ElementSize + +```go +func (p QueryIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that QueryIdᵖ points to. + +#### func (QueryIdᵖ) Read + +```go +func (p QueryIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) QueryId +``` +Read reads and returns the QueryId element at the pointer. + +#### func (QueryIdᵖ) Slice + +```go +func (p QueryIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) QueryIdˢ +``` +Slice returns a new QueryIdˢ from the pointer using start and end indices. + +#### func (QueryIdᵖ) String + +```go +func (p QueryIdᵖ) String() string +``` +String returns a string description of the QueryIdᵖ pointer. + +#### func (QueryIdᵖ) Write + +```go +func (p QueryIdᵖ) Write(value QueryId, ϟs *gfxapi.State) +``` +Write writes value to the QueryId element at the pointer. + #### type QueryObjectParameter ```go @@ -17560,6 +26238,12 @@ type QueryObjectParameter uint32 enum QueryObjectParameter ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryObjectParameter) Parse + +```go +func (v *QueryObjectParameter) Parse(s string) error +``` + #### func (QueryObjectParameter) String ```go @@ -17576,12 +26260,6 @@ type QueryObjectParameter_EXT_disjoint_timer_query uint32 enum QueryObjectParameter_EXT_disjoint_timer_query ////////////////////////////////////////////////////////////////////////////// -#### func (QueryObjectParameter_EXT_disjoint_timer_query) String - -```go -func (v QueryObjectParameter_EXT_disjoint_timer_query) String() string -``` - #### type QueryObjectParameter_GLES_3 ```go @@ -17592,6 +26270,12 @@ type QueryObjectParameter_GLES_3 uint32 enum QueryObjectParameter_GLES_3 ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryObjectParameter_GLES_3) Parse + +```go +func (v *QueryObjectParameter_GLES_3) Parse(s string) error +``` + #### func (QueryObjectParameter_GLES_3) String ```go @@ -17608,6 +26292,12 @@ type QueryParameter uint32 enum QueryParameter ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryParameter) Parse + +```go +func (v *QueryParameter) Parse(s string) error +``` + #### func (QueryParameter) String ```go @@ -17624,6 +26314,12 @@ type QueryParameter_EXT_disjoint_timer_query uint32 enum QueryParameter_EXT_disjoint_timer_query ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryParameter_EXT_disjoint_timer_query) Parse + +```go +func (v *QueryParameter_EXT_disjoint_timer_query) Parse(s string) error +``` + #### func (QueryParameter_EXT_disjoint_timer_query) String ```go @@ -17640,41 +26336,16 @@ type QueryParameter_GLES_3 uint32 enum QueryParameter_GLES_3 ////////////////////////////////////////////////////////////////////////////// -#### func (QueryParameter_GLES_3) String - -```go -func (v QueryParameter_GLES_3) String() string -``` - -#### type QueryPtr_QueryIdMap +#### func (*QueryParameter_GLES_3) Parse ```go -type QueryPtr_QueryIdMap map[QueryId]*Query +func (v *QueryParameter_GLES_3) Parse(s string) error ``` - -#### func (QueryPtr_QueryIdMap) Contains - -```go -func (m QueryPtr_QueryIdMap) Contains(key QueryId) bool -``` - -#### func (QueryPtr_QueryIdMap) Delete - -```go -func (m QueryPtr_QueryIdMap) Delete(key QueryId) -``` - -#### func (QueryPtr_QueryIdMap) Get - -```go -func (m QueryPtr_QueryIdMap) Get(key QueryId) *Query -``` - -#### func (QueryPtr_QueryIdMap) Range +#### func (QueryParameter_GLES_3) String ```go -func (m QueryPtr_QueryIdMap) Range() []*Query +func (v QueryParameter_GLES_3) String() string ``` #### type QueryTarget @@ -17687,6 +26358,12 @@ type QueryTarget uint32 enum QueryTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryTarget) Parse + +```go +func (v *QueryTarget) Parse(s string) error +``` + #### func (QueryTarget) String ```go @@ -17703,6 +26380,12 @@ type QueryTarget_EXT_disjoint_timer_query uint32 enum QueryTarget_EXT_disjoint_timer_query ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryTarget_EXT_disjoint_timer_query) Parse + +```go +func (v *QueryTarget_EXT_disjoint_timer_query) Parse(s string) error +``` + #### func (QueryTarget_EXT_disjoint_timer_query) String ```go @@ -17719,6 +26402,12 @@ type QueryTarget_GLES_3 uint32 enum QueryTarget_GLES_3 ////////////////////////////////////////////////////////////////////////////// +#### func (*QueryTarget_GLES_3) Parse + +```go +func (v *QueryTarget_GLES_3) Parse(s string) error +``` + #### func (QueryTarget_GLES_3) String ```go @@ -17739,7 +26428,7 @@ type RasterizerState struct { ColorMaskGreen bool ColorMaskBlue bool ColorMaskAlpha bool - StencilMask U32_FaceModeMap + StencilMask FaceModeːu32ᵐ Viewport Rect Scissor Rect FrontFace FaceOrientation @@ -17817,7 +26506,7 @@ type Renderbuffer struct { CreatedAt atom.ID Width int32 Height int32 - Data memory.Memory + Data U8ˢ Format RenderbufferFormat } ``` @@ -17844,155 +26533,270 @@ func (c *Renderbuffer) GetCreatedAt() atom.ID func (c *Renderbuffer) Init() ``` -#### type RenderbufferArray +#### type RenderbufferFormat ```go -type RenderbufferArray []Renderbuffer +type RenderbufferFormat uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum RenderbufferFormat +////////////////////////////////////////////////////////////////////////////// -#### func (RenderbufferArray) Len +#### func (*RenderbufferFormat) Parse ```go -func (s RenderbufferArray) Len() int +func (v *RenderbufferFormat) Parse(s string) error ``` -#### func (RenderbufferArray) Range +#### func (RenderbufferFormat) String ```go -func (s RenderbufferArray) Range() []Renderbuffer +func (v RenderbufferFormat) String() string ``` -#### type RenderbufferFormat +#### type RenderbufferId ```go -type RenderbufferFormat uint32 +type RenderbufferId uint32 ``` -////////////////////////////////////////////////////////////////////////////// -enum RenderbufferFormat -////////////////////////////////////////////////////////////////////////////// -#### func (RenderbufferFormat) String +#### type RenderbufferIdːRenderbufferʳᵐ ```go -func (v RenderbufferFormat) String() string +type RenderbufferIdːRenderbufferʳᵐ map[RenderbufferId](*Renderbuffer) ``` -#### type RenderbufferId + +#### func (RenderbufferIdːRenderbufferʳᵐ) Contains ```go -type RenderbufferId uint32 +func (m RenderbufferIdːRenderbufferʳᵐ) Contains(key RenderbufferId) bool ``` +#### func (RenderbufferIdːRenderbufferʳᵐ) Delete -#### func (*RenderbufferId) Equal +```go +func (m RenderbufferIdːRenderbufferʳᵐ) Delete(key RenderbufferId) +``` + +#### func (RenderbufferIdːRenderbufferʳᵐ) Get ```go -func (c *RenderbufferId) Equal(rhs RenderbufferId) bool +func (m RenderbufferIdːRenderbufferʳᵐ) Get(key RenderbufferId) *Renderbuffer ``` -#### func (*RenderbufferId) Less +#### func (RenderbufferIdːRenderbufferʳᵐ) Range ```go -func (c *RenderbufferId) Less(rhs RenderbufferId) bool +func (m RenderbufferIdːRenderbufferʳᵐ) Range() [](*Renderbuffer) ``` -#### type RenderbufferIdArray +#### type RenderbufferIdˢ ```go -type RenderbufferIdArray []RenderbufferId +type RenderbufferIdˢ struct { + binary.Generate + SliceInfo +} ``` +RenderbufferIdˢ is a slice of RenderbufferId. -#### func (RenderbufferIdArray) Len +#### func AsRenderbufferIdˢ ```go -func (s RenderbufferIdArray) Len() int +func AsRenderbufferIdˢ(s Slice, ϟs *gfxapi.State) RenderbufferIdˢ ``` +AsRenderbufferIdˢ returns s cast to a RenderbufferIdˢ. The returned slice length +will be calculated so that the returned slice is no longer (in bytes) than s. -#### func (RenderbufferIdArray) Range +#### func MakeRenderbufferIdˢ ```go -func (s RenderbufferIdArray) Range() []RenderbufferId +func MakeRenderbufferIdˢ(count uint64, ϟs *gfxapi.State) RenderbufferIdˢ ``` +MakeRenderbufferIdˢ returns a RenderbufferIdˢ backed by a new memory pool. -#### type RenderbufferId_RenderbufferTargetMap +#### func (*RenderbufferIdˢ) Class ```go -type RenderbufferId_RenderbufferTargetMap map[RenderbufferTarget]RenderbufferId +func (*RenderbufferIdˢ) Class() binary.Class ``` +#### func (RenderbufferIdˢ) Clone -#### func (RenderbufferId_RenderbufferTargetMap) Contains +```go +func (s RenderbufferIdˢ) Clone(ϟs *gfxapi.State) RenderbufferIdˢ +``` +Clone returns a copy of the RenderbufferIdˢ in a new memory pool. + +#### func (RenderbufferIdˢ) Copy ```go -func (m RenderbufferId_RenderbufferTargetMap) Contains(key RenderbufferTarget) bool +func (dst RenderbufferIdˢ) Copy(src RenderbufferIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s RenderbufferIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (RenderbufferId_RenderbufferTargetMap) Delete +#### func (RenderbufferIdˢ) Decoder ```go -func (m RenderbufferId_RenderbufferTargetMap) Delete(key RenderbufferTarget) +func (s RenderbufferIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (RenderbufferId_RenderbufferTargetMap) Get +#### func (RenderbufferIdˢ) ElementSize ```go -func (m RenderbufferId_RenderbufferTargetMap) Get(key RenderbufferTarget) RenderbufferId +func (s RenderbufferIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that RenderbufferIdˢ points +to. -#### func (RenderbufferId_RenderbufferTargetMap) Range +#### func (RenderbufferIdˢ) Encoder ```go -func (m RenderbufferId_RenderbufferTargetMap) Range() []RenderbufferId +func (s RenderbufferIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### type RenderbufferParameter +#### func (RenderbufferIdˢ) Index ```go -type RenderbufferParameter uint32 +func (s RenderbufferIdˢ) Index(i uint64, ϟs *gfxapi.State) RenderbufferIdᵖ ``` +Index returns a RenderbufferIdᵖ to the i'th element in this RenderbufferIdˢ. -////////////////////////////////////////////////////////////////////////////// -enum RenderbufferParameter -////////////////////////////////////////////////////////////////////////////// +#### func (RenderbufferIdˢ) Range -#### func (RenderbufferParameter) String +```go +func (s RenderbufferIdˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (RenderbufferIdˢ) Read ```go -func (v RenderbufferParameter) String() string +func (s RenderbufferIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []RenderbufferId +``` +Read reads and returns all the RenderbufferId elements in this RenderbufferIdˢ. + +#### func (RenderbufferIdˢ) ResourceID + +```go +func (s RenderbufferIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (RenderbufferIdˢ) Slice + +```go +func (s RenderbufferIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) RenderbufferIdˢ +``` +Slice returns a sub-slice from the RenderbufferIdˢ using start and end indices. + +#### func (RenderbufferIdˢ) String + +```go +func (s RenderbufferIdˢ) String() string +``` +String returns a string description of the RenderbufferIdˢ slice. + +#### func (RenderbufferIdˢ) Write + +```go +func (dst RenderbufferIdˢ) Write(src []RenderbufferId, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type RenderbufferIdᵖ + +```go +type RenderbufferIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +RenderbufferIdᵖ is a pointer to a RenderbufferId element. + +#### func NewRenderbufferIdᵖ + +```go +func NewRenderbufferIdᵖ(addr memory.Pointer) RenderbufferIdᵖ +``` +NewRenderbufferIdᵖ returns a RenderbufferIdᵖ that points to addr in the +application pool. + +#### func (*RenderbufferIdᵖ) Class + +```go +func (*RenderbufferIdᵖ) Class() binary.Class ``` -#### type RenderbufferPtr_RenderbufferIdMap +#### func (RenderbufferIdᵖ) ElementSize ```go -type RenderbufferPtr_RenderbufferIdMap map[RenderbufferId]*Renderbuffer +func (p RenderbufferIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that RenderbufferIdᵖ points +to. + +#### func (RenderbufferIdᵖ) Read +```go +func (p RenderbufferIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) RenderbufferId +``` +Read reads and returns the RenderbufferId element at the pointer. -#### func (RenderbufferPtr_RenderbufferIdMap) Contains +#### func (RenderbufferIdᵖ) Slice ```go -func (m RenderbufferPtr_RenderbufferIdMap) Contains(key RenderbufferId) bool +func (p RenderbufferIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) RenderbufferIdˢ ``` +Slice returns a new RenderbufferIdˢ from the pointer using start and end +indices. -#### func (RenderbufferPtr_RenderbufferIdMap) Delete +#### func (RenderbufferIdᵖ) String ```go -func (m RenderbufferPtr_RenderbufferIdMap) Delete(key RenderbufferId) +func (p RenderbufferIdᵖ) String() string ``` +String returns a string description of the RenderbufferIdᵖ pointer. -#### func (RenderbufferPtr_RenderbufferIdMap) Get +#### func (RenderbufferIdᵖ) Write ```go -func (m RenderbufferPtr_RenderbufferIdMap) Get(key RenderbufferId) *Renderbuffer +func (p RenderbufferIdᵖ) Write(value RenderbufferId, ϟs *gfxapi.State) ``` +Write writes value to the RenderbufferId element at the pointer. -#### func (RenderbufferPtr_RenderbufferIdMap) Range +#### type RenderbufferParameter ```go -func (m RenderbufferPtr_RenderbufferIdMap) Range() []*Renderbuffer +type RenderbufferParameter uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum RenderbufferParameter +////////////////////////////////////////////////////////////////////////////// + +#### func (*RenderbufferParameter) Parse + +```go +func (v *RenderbufferParameter) Parse(s string) error +``` + +#### func (RenderbufferParameter) String + +```go +func (v RenderbufferParameter) String() string ``` #### type RenderbufferTarget @@ -18005,17 +26809,55 @@ type RenderbufferTarget uint32 enum RenderbufferTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*RenderbufferTarget) Parse + +```go +func (v *RenderbufferTarget) Parse(s string) error +``` + #### func (RenderbufferTarget) String ```go func (v RenderbufferTarget) String() string ``` +#### type RenderbufferTargetːRenderbufferIdᵐ + +```go +type RenderbufferTargetːRenderbufferIdᵐ map[RenderbufferTarget]RenderbufferId +``` + + +#### func (RenderbufferTargetːRenderbufferIdᵐ) Contains + +```go +func (m RenderbufferTargetːRenderbufferIdᵐ) Contains(key RenderbufferTarget) bool +``` + +#### func (RenderbufferTargetːRenderbufferIdᵐ) Delete + +```go +func (m RenderbufferTargetːRenderbufferIdᵐ) Delete(key RenderbufferTarget) +``` + +#### func (RenderbufferTargetːRenderbufferIdᵐ) Get + +```go +func (m RenderbufferTargetːRenderbufferIdᵐ) Get(key RenderbufferTarget) RenderbufferId +``` + +#### func (RenderbufferTargetːRenderbufferIdᵐ) Range + +```go +func (m RenderbufferTargetːRenderbufferIdᵐ) Range() []RenderbufferId +``` + #### type ReplayBindRenderer ```go type ReplayBindRenderer struct { binary.Generate + Id uint32 } ``` @@ -18027,9 +26869,7 @@ ReplayBindRenderer #### func NewReplayBindRenderer ```go -func NewReplayBindRenderer( - pId uint32, -) *ReplayBindRenderer +func NewReplayBindRenderer(Id uint32) *ReplayBindRenderer ``` #### func (*ReplayBindRenderer) API @@ -18038,6 +26878,24 @@ func NewReplayBindRenderer( func (c *ReplayBindRenderer) API() gfxapi.API ``` +#### func (*ReplayBindRenderer) AddRead + +```go +func (a *ReplayBindRenderer) AddRead(rng memory.Range, id binary.ID) *ReplayBindRenderer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The ReplayBindRenderer pointer is returned so that calls can be +chained. + +#### func (*ReplayBindRenderer) AddWrite + +```go +func (a *ReplayBindRenderer) AddWrite(rng memory.Range, id binary.ID) *ReplayBindRenderer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The ReplayBindRenderer pointer is returned so that calls can be +chained. + #### func (*ReplayBindRenderer) Class ```go @@ -18053,19 +26911,25 @@ func (c *ReplayBindRenderer) Flags() atom.Flags #### func (*ReplayBindRenderer) Mutate ```go -func (ϟa *ReplayBindRenderer) Mutate(ϟs *gfxapi.State) error +func (ϟa *ReplayBindRenderer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*ReplayBindRenderer) Observations + +```go +func (a *ReplayBindRenderer) Observations() *atom.Observations ``` #### func (*ReplayBindRenderer) Replay ```go -func (ϟa *ReplayBindRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *ReplayBindRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*ReplayBindRenderer) String ```go -func (c *ReplayBindRenderer) String() string +func (a *ReplayBindRenderer) String() string ``` #### func (*ReplayBindRenderer) TypeID @@ -18079,6 +26943,7 @@ func (c *ReplayBindRenderer) TypeID() atom.TypeID ```go type ReplayCreateRenderer struct { binary.Generate + Id uint32 } ``` @@ -18090,9 +26955,7 @@ ReplayCreateRenderer #### func NewReplayCreateRenderer ```go -func NewReplayCreateRenderer( - pId uint32, -) *ReplayCreateRenderer +func NewReplayCreateRenderer(Id uint32) *ReplayCreateRenderer ``` #### func (*ReplayCreateRenderer) API @@ -18101,6 +26964,24 @@ func NewReplayCreateRenderer( func (c *ReplayCreateRenderer) API() gfxapi.API ``` +#### func (*ReplayCreateRenderer) AddRead + +```go +func (a *ReplayCreateRenderer) AddRead(rng memory.Range, id binary.ID) *ReplayCreateRenderer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The ReplayCreateRenderer pointer is returned so that calls can be +chained. + +#### func (*ReplayCreateRenderer) AddWrite + +```go +func (a *ReplayCreateRenderer) AddWrite(rng memory.Range, id binary.ID) *ReplayCreateRenderer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The ReplayCreateRenderer pointer is returned so that calls can be +chained. + #### func (*ReplayCreateRenderer) Class ```go @@ -18116,19 +26997,25 @@ func (c *ReplayCreateRenderer) Flags() atom.Flags #### func (*ReplayCreateRenderer) Mutate ```go -func (ϟa *ReplayCreateRenderer) Mutate(ϟs *gfxapi.State) error +func (ϟa *ReplayCreateRenderer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*ReplayCreateRenderer) Observations + +```go +func (a *ReplayCreateRenderer) Observations() *atom.Observations ``` #### func (*ReplayCreateRenderer) Replay ```go -func (ϟa *ReplayCreateRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *ReplayCreateRenderer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*ReplayCreateRenderer) String ```go -func (c *ReplayCreateRenderer) String() string +func (a *ReplayCreateRenderer) String() string ``` #### func (*ReplayCreateRenderer) TypeID @@ -18147,61 +27034,518 @@ type ResetStatus uint32 enum ResetStatus ////////////////////////////////////////////////////////////////////////////// +#### func (*ResetStatus) Parse + +```go +func (v *ResetStatus) Parse(s string) error +``` + #### func (ResetStatus) String ```go func (v ResetStatus) String() string ``` -#### type S32Array +#### type S32ː2ᵃ + +```go +type S32ː2ᵃ struct { + binary.Generate + Elements [2]int32 +} +``` + + +#### func (*S32ː2ᵃ) Class + +```go +func (*S32ː2ᵃ) Class() binary.Class +``` + +#### type S32ː3ᵃ + +```go +type S32ː3ᵃ struct { + binary.Generate + Elements [3]int32 +} +``` + + +#### func (*S32ː3ᵃ) Class + +```go +func (*S32ː3ᵃ) Class() binary.Class +``` + +#### type S32ː4ᵃ + +```go +type S32ː4ᵃ struct { + binary.Generate + Elements [4]int32 +} +``` + + +#### func (*S32ː4ᵃ) Class + +```go +func (*S32ː4ᵃ) Class() binary.Class +``` + +#### type S32ːCubemapLevelᵐ + +```go +type S32ːCubemapLevelᵐ map[int32]CubemapLevel +``` + + +#### func (S32ːCubemapLevelᵐ) Contains + +```go +func (m S32ːCubemapLevelᵐ) Contains(key int32) bool +``` + +#### func (S32ːCubemapLevelᵐ) Delete + +```go +func (m S32ːCubemapLevelᵐ) Delete(key int32) +``` + +#### func (S32ːCubemapLevelᵐ) Get + +```go +func (m S32ːCubemapLevelᵐ) Get(key int32) CubemapLevel +``` + +#### func (S32ːCubemapLevelᵐ) Range + +```go +func (m S32ːCubemapLevelᵐ) Range() []CubemapLevel +``` + +#### type S32ːImageᵐ + +```go +type S32ːImageᵐ map[int32]Image +``` + + +#### func (S32ːImageᵐ) Contains + +```go +func (m S32ːImageᵐ) Contains(key int32) bool +``` + +#### func (S32ːImageᵐ) Delete + +```go +func (m S32ːImageᵐ) Delete(key int32) +``` + +#### func (S32ːImageᵐ) Get + +```go +func (m S32ːImageᵐ) Get(key int32) Image +``` + +#### func (S32ːImageᵐ) Range + +```go +func (m S32ːImageᵐ) Range() []Image +``` + +#### type S32ːVertexAttributeᵐ + +```go +type S32ːVertexAttributeᵐ map[int32]VertexAttribute +``` + + +#### func (S32ːVertexAttributeᵐ) Contains + +```go +func (m S32ːVertexAttributeᵐ) Contains(key int32) bool +``` + +#### func (S32ːVertexAttributeᵐ) Delete + +```go +func (m S32ːVertexAttributeᵐ) Delete(key int32) +``` + +#### func (S32ːVertexAttributeᵐ) Get + +```go +func (m S32ːVertexAttributeᵐ) Get(key int32) VertexAttribute +``` + +#### func (S32ːVertexAttributeᵐ) Range + +```go +func (m S32ːVertexAttributeᵐ) Range() []VertexAttribute +``` + +#### type S32ˢ + +```go +type S32ˢ struct { + binary.Generate + SliceInfo +} +``` + +S32ˢ is a slice of int32. + +#### func AsS32ˢ + +```go +func AsS32ˢ(s Slice, ϟs *gfxapi.State) S32ˢ +``` +AsS32ˢ returns s cast to a S32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS32ˢ + +```go +func MakeS32ˢ(count uint64, ϟs *gfxapi.State) S32ˢ +``` +MakeS32ˢ returns a S32ˢ backed by a new memory pool. + +#### func (*S32ˢ) Class + +```go +func (*S32ˢ) Class() binary.Class +``` + +#### func (S32ˢ) Clone + +```go +func (s S32ˢ) Clone(ϟs *gfxapi.State) S32ˢ +``` +Clone returns a copy of the S32ˢ in a new memory pool. + +#### func (S32ˢ) Copy + +```go +func (dst S32ˢ) Copy(src S32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S32ˢ) Decoder + +```go +func (s S32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S32ˢ) ElementSize + +```go +func (s S32ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S32ˢ points to. + +#### func (S32ˢ) Encoder + +```go +func (s S32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S32ˢ) Index + +```go +func (s S32ˢ) Index(i uint64, ϟs *gfxapi.State) S32ᵖ +``` +Index returns a S32ᵖ to the i'th element in this S32ˢ. + +#### func (S32ˢ) Range + +```go +func (s S32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S32ˢ) Read + +```go +func (s S32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int32 +``` +Read reads and returns all the int32 elements in this S32ˢ. + +#### func (S32ˢ) ResourceID + +```go +func (s S32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S32ˢ) Slice + +```go +func (s S32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S32ˢ +``` +Slice returns a sub-slice from the S32ˢ using start and end indices. + +#### func (S32ˢ) String + +```go +func (s S32ˢ) String() string +``` +String returns a string description of the S32ˢ slice. + +#### func (S32ˢ) Write + +```go +func (dst S32ˢ) Write(src []int32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type S32ᵖ + +```go +type S32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +S32ᵖ is a pointer to a int32 element. + +#### func NewS32ᵖ + +```go +func NewS32ᵖ(addr memory.Pointer) S32ᵖ +``` +NewS32ᵖ returns a S32ᵖ that points to addr in the application pool. + +#### func (*S32ᵖ) Class + +```go +func (*S32ᵖ) Class() binary.Class +``` + +#### func (S32ᵖ) ElementSize + +```go +func (p S32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S32ᵖ points to. + +#### func (S32ᵖ) Read + +```go +func (p S32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int32 +``` +Read reads and returns the int32 element at the pointer. + +#### func (S32ᵖ) Slice + +```go +func (p S32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S32ˢ +``` +Slice returns a new S32ˢ from the pointer using start and end indices. + +#### func (S32ᵖ) String + +```go +func (p S32ᵖ) String() string +``` +String returns a string description of the S32ᵖ pointer. + +#### func (S32ᵖ) Write + +```go +func (p S32ᵖ) Write(value int32, ϟs *gfxapi.State) +``` +Write writes value to the int32 element at the pointer. + +#### type S64ˢ + +```go +type S64ˢ struct { + binary.Generate + SliceInfo +} +``` + +S64ˢ is a slice of int64. + +#### func AsS64ˢ + +```go +func AsS64ˢ(s Slice, ϟs *gfxapi.State) S64ˢ +``` +AsS64ˢ returns s cast to a S64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS64ˢ ```go -type S32Array []int32 +func MakeS64ˢ(count uint64, ϟs *gfxapi.State) S64ˢ ``` +MakeS64ˢ returns a S64ˢ backed by a new memory pool. + +#### func (*S64ˢ) Class + +```go +func (*S64ˢ) Class() binary.Class +``` + +#### func (S64ˢ) Clone + +```go +func (s S64ˢ) Clone(ϟs *gfxapi.State) S64ˢ +``` +Clone returns a copy of the S64ˢ in a new memory pool. + +#### func (S64ˢ) Copy + +```go +func (dst S64ˢ) Copy(src S64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S64ˢ) Decoder + +```go +func (s S64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S64ˢ) ElementSize +```go +func (s S64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S64ˢ points to. + +#### func (S64ˢ) Encoder + +```go +func (s S64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S64ˢ) Index + +```go +func (s S64ˢ) Index(i uint64, ϟs *gfxapi.State) S64ᵖ +``` +Index returns a S64ᵖ to the i'th element in this S64ˢ. + +#### func (S64ˢ) Range + +```go +func (s S64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S64ˢ) Read + +```go +func (s S64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int64 +``` +Read reads and returns all the int64 elements in this S64ˢ. + +#### func (S64ˢ) ResourceID + +```go +func (s S64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S64ˢ) Slice + +```go +func (s S64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S64ˢ +``` +Slice returns a sub-slice from the S64ˢ using start and end indices. + +#### func (S64ˢ) String + +```go +func (s S64ˢ) String() string +``` +String returns a string description of the S64ˢ slice. + +#### func (S64ˢ) Write + +```go +func (dst S64ˢ) Write(src []int64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### func (S32Array) Len +#### type S64ᵖ ```go -func (s S32Array) Len() int +type S64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (S32Array) Range +S64ᵖ is a pointer to a int64 element. + +#### func NewS64ᵖ ```go -func (s S32Array) Range() []int32 +func NewS64ᵖ(addr memory.Pointer) S64ᵖ ``` +NewS64ᵖ returns a S64ᵖ that points to addr in the application pool. -#### type S32_PixelStoreParameterMap +#### func (*S64ᵖ) Class ```go -type S32_PixelStoreParameterMap map[PixelStoreParameter]int32 +func (*S64ᵖ) Class() binary.Class ``` +#### func (S64ᵖ) ElementSize -#### func (S32_PixelStoreParameterMap) Contains +```go +func (p S64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S64ᵖ points to. + +#### func (S64ᵖ) Read ```go -func (m S32_PixelStoreParameterMap) Contains(key PixelStoreParameter) bool +func (p S64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int64 ``` +Read reads and returns the int64 element at the pointer. -#### func (S32_PixelStoreParameterMap) Delete +#### func (S64ᵖ) Slice ```go -func (m S32_PixelStoreParameterMap) Delete(key PixelStoreParameter) +func (p S64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S64ˢ ``` +Slice returns a new S64ˢ from the pointer using start and end indices. -#### func (S32_PixelStoreParameterMap) Get +#### func (S64ᵖ) String ```go -func (m S32_PixelStoreParameterMap) Get(key PixelStoreParameter) int32 +func (p S64ᵖ) String() string ``` +String returns a string description of the S64ᵖ pointer. -#### func (S32_PixelStoreParameterMap) Range +#### func (S64ᵖ) Write ```go -func (m S32_PixelStoreParameterMap) Range() []int32 +func (p S64ᵖ) Write(value int64, ϟs *gfxapi.State) ``` +Write writes value to the int64 element at the pointer. #### type Shader @@ -18209,11 +27553,11 @@ func (m S32_PixelStoreParameterMap) Range() []int32 type Shader struct { binary.Generate CreatedAt atom.ID - Binary memory.Memory + Binary U8ˢ Compiled bool Deletable bool - InfoLog string - Source []string + InfoLog Charˢ + Source string Type ShaderType } ``` @@ -18240,40 +27584,214 @@ func (c *Shader) GetCreatedAt() atom.ID func (c *Shader) Init() ``` -#### type ShaderArray +#### type ShaderAttribType ```go -type ShaderArray []Shader +type ShaderAttribType uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum ShaderAttribType +////////////////////////////////////////////////////////////////////////////// -#### func (ShaderArray) Len +#### func (*ShaderAttribType) Parse ```go -func (s ShaderArray) Len() int +func (v *ShaderAttribType) Parse(s string) error ``` -#### func (ShaderArray) Range +#### func (ShaderAttribType) String ```go -func (s ShaderArray) Range() []Shader +func (v ShaderAttribType) String() string ``` -#### type ShaderAttribType +#### type ShaderAttribTypeˢ ```go -type ShaderAttribType uint32 +type ShaderAttribTypeˢ struct { + binary.Generate + SliceInfo +} ``` -////////////////////////////////////////////////////////////////////////////// -enum ShaderAttribType -////////////////////////////////////////////////////////////////////////////// +ShaderAttribTypeˢ is a slice of ShaderAttribType. -#### func (ShaderAttribType) String +#### func AsShaderAttribTypeˢ ```go -func (v ShaderAttribType) String() string +func AsShaderAttribTypeˢ(s Slice, ϟs *gfxapi.State) ShaderAttribTypeˢ +``` +AsShaderAttribTypeˢ returns s cast to a ShaderAttribTypeˢ. The returned slice +length will be calculated so that the returned slice is no longer (in bytes) +than s. + +#### func MakeShaderAttribTypeˢ + +```go +func MakeShaderAttribTypeˢ(count uint64, ϟs *gfxapi.State) ShaderAttribTypeˢ +``` +MakeShaderAttribTypeˢ returns a ShaderAttribTypeˢ backed by a new memory pool. + +#### func (*ShaderAttribTypeˢ) Class + +```go +func (*ShaderAttribTypeˢ) Class() binary.Class +``` + +#### func (ShaderAttribTypeˢ) Clone + +```go +func (s ShaderAttribTypeˢ) Clone(ϟs *gfxapi.State) ShaderAttribTypeˢ +``` +Clone returns a copy of the ShaderAttribTypeˢ in a new memory pool. + +#### func (ShaderAttribTypeˢ) Copy + +```go +func (dst ShaderAttribTypeˢ) Copy(src ShaderAttribTypeˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s ShaderAttribTypeˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (ShaderAttribTypeˢ) Decoder + +```go +func (s ShaderAttribTypeˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (ShaderAttribTypeˢ) ElementSize + +```go +func (s ShaderAttribTypeˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that ShaderAttribTypeˢ +points to. + +#### func (ShaderAttribTypeˢ) Encoder + +```go +func (s ShaderAttribTypeˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (ShaderAttribTypeˢ) Index + +```go +func (s ShaderAttribTypeˢ) Index(i uint64, ϟs *gfxapi.State) ShaderAttribTypeᵖ +``` +Index returns a ShaderAttribTypeᵖ to the i'th element in this ShaderAttribTypeˢ. + +#### func (ShaderAttribTypeˢ) Range + +```go +func (s ShaderAttribTypeˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (ShaderAttribTypeˢ) Read + +```go +func (s ShaderAttribTypeˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []ShaderAttribType +``` +Read reads and returns all the ShaderAttribType elements in this +ShaderAttribTypeˢ. + +#### func (ShaderAttribTypeˢ) ResourceID + +```go +func (s ShaderAttribTypeˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (ShaderAttribTypeˢ) Slice + +```go +func (s ShaderAttribTypeˢ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderAttribTypeˢ +``` +Slice returns a sub-slice from the ShaderAttribTypeˢ using start and end +indices. + +#### func (ShaderAttribTypeˢ) String + +```go +func (s ShaderAttribTypeˢ) String() string +``` +String returns a string description of the ShaderAttribTypeˢ slice. + +#### func (ShaderAttribTypeˢ) Write + +```go +func (dst ShaderAttribTypeˢ) Write(src []ShaderAttribType, ϟs *gfxapi.State) uint64 ``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type ShaderAttribTypeᵖ + +```go +type ShaderAttribTypeᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +ShaderAttribTypeᵖ is a pointer to a ShaderAttribType element. + +#### func NewShaderAttribTypeᵖ + +```go +func NewShaderAttribTypeᵖ(addr memory.Pointer) ShaderAttribTypeᵖ +``` +NewShaderAttribTypeᵖ returns a ShaderAttribTypeᵖ that points to addr in the +application pool. + +#### func (*ShaderAttribTypeᵖ) Class + +```go +func (*ShaderAttribTypeᵖ) Class() binary.Class +``` + +#### func (ShaderAttribTypeᵖ) ElementSize + +```go +func (p ShaderAttribTypeᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that ShaderAttribTypeᵖ +points to. + +#### func (ShaderAttribTypeᵖ) Read + +```go +func (p ShaderAttribTypeᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) ShaderAttribType +``` +Read reads and returns the ShaderAttribType element at the pointer. + +#### func (ShaderAttribTypeᵖ) Slice + +```go +func (p ShaderAttribTypeᵖ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderAttribTypeˢ +``` +Slice returns a new ShaderAttribTypeˢ from the pointer using start and end +indices. + +#### func (ShaderAttribTypeᵖ) String + +```go +func (p ShaderAttribTypeᵖ) String() string +``` +String returns a string description of the ShaderAttribTypeᵖ pointer. + +#### func (ShaderAttribTypeᵖ) Write + +```go +func (p ShaderAttribTypeᵖ) Write(value ShaderAttribType, ϟs *gfxapi.State) +``` +Write writes value to the ShaderAttribType element at the pointer. #### type ShaderId @@ -18282,113 +27800,237 @@ type ShaderId uint32 ``` -#### func (*ShaderId) Equal +#### type ShaderIdːShaderʳᵐ ```go -func (c *ShaderId) Equal(rhs ShaderId) bool +type ShaderIdːShaderʳᵐ map[ShaderId](*Shader) ``` -#### func (*ShaderId) Less + +#### func (ShaderIdːShaderʳᵐ) Contains + +```go +func (m ShaderIdːShaderʳᵐ) Contains(key ShaderId) bool +``` + +#### func (ShaderIdːShaderʳᵐ) Delete ```go -func (c *ShaderId) Less(rhs ShaderId) bool +func (m ShaderIdːShaderʳᵐ) Delete(key ShaderId) ``` -#### type ShaderIdArray +#### func (ShaderIdːShaderʳᵐ) Get ```go -type ShaderIdArray []ShaderId +func (m ShaderIdːShaderʳᵐ) Get(key ShaderId) *Shader ``` +#### func (ShaderIdːShaderʳᵐ) Range + +```go +func (m ShaderIdːShaderʳᵐ) Range() [](*Shader) +``` -#### func (ShaderIdArray) Len +#### type ShaderIdˢ ```go -func (s ShaderIdArray) Len() int +type ShaderIdˢ struct { + binary.Generate + SliceInfo +} ``` -#### func (ShaderIdArray) Range +ShaderIdˢ is a slice of ShaderId. + +#### func AsShaderIdˢ ```go -func (s ShaderIdArray) Range() []ShaderId +func AsShaderIdˢ(s Slice, ϟs *gfxapi.State) ShaderIdˢ ``` +AsShaderIdˢ returns s cast to a ShaderIdˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### type ShaderId_ShaderTypeMap +#### func MakeShaderIdˢ ```go -type ShaderId_ShaderTypeMap map[ShaderType]ShaderId +func MakeShaderIdˢ(count uint64, ϟs *gfxapi.State) ShaderIdˢ ``` +MakeShaderIdˢ returns a ShaderIdˢ backed by a new memory pool. +#### func (*ShaderIdˢ) Class -#### func (ShaderId_ShaderTypeMap) Contains +```go +func (*ShaderIdˢ) Class() binary.Class +``` + +#### func (ShaderIdˢ) Clone ```go -func (m ShaderId_ShaderTypeMap) Contains(key ShaderType) bool +func (s ShaderIdˢ) Clone(ϟs *gfxapi.State) ShaderIdˢ ``` +Clone returns a copy of the ShaderIdˢ in a new memory pool. -#### func (ShaderId_ShaderTypeMap) Delete +#### func (ShaderIdˢ) Copy ```go -func (m ShaderId_ShaderTypeMap) Delete(key ShaderType) +func (dst ShaderIdˢ) Copy(src ShaderIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s ShaderIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (ShaderId_ShaderTypeMap) Get +#### func (ShaderIdˢ) Decoder ```go -func (m ShaderId_ShaderTypeMap) Get(key ShaderType) ShaderId +func (s ShaderIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (ShaderId_ShaderTypeMap) Range +#### func (ShaderIdˢ) ElementSize ```go -func (m ShaderId_ShaderTypeMap) Range() []ShaderId +func (s ShaderIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that ShaderIdˢ points to. -#### type ShaderParameter +#### func (ShaderIdˢ) Encoder ```go -type ShaderParameter uint32 +func (s ShaderIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -////////////////////////////////////////////////////////////////////////////// -enum ShaderParameter -////////////////////////////////////////////////////////////////////////////// +#### func (ShaderIdˢ) Index -#### func (ShaderParameter) String +```go +func (s ShaderIdˢ) Index(i uint64, ϟs *gfxapi.State) ShaderIdᵖ +``` +Index returns a ShaderIdᵖ to the i'th element in this ShaderIdˢ. + +#### func (ShaderIdˢ) Range ```go -func (v ShaderParameter) String() string +func (s ShaderIdˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (ShaderIdˢ) Read + +```go +func (s ShaderIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []ShaderId +``` +Read reads and returns all the ShaderId elements in this ShaderIdˢ. + +#### func (ShaderIdˢ) ResourceID + +```go +func (s ShaderIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (ShaderIdˢ) Slice + +```go +func (s ShaderIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderIdˢ ``` +Slice returns a sub-slice from the ShaderIdˢ using start and end indices. -#### type ShaderPtr_ShaderIdMap +#### func (ShaderIdˢ) String ```go -type ShaderPtr_ShaderIdMap map[ShaderId]*Shader +func (s ShaderIdˢ) String() string ``` +String returns a string description of the ShaderIdˢ slice. + +#### func (ShaderIdˢ) Write +```go +func (dst ShaderIdˢ) Write(src []ShaderId, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. -#### func (ShaderPtr_ShaderIdMap) Contains +#### type ShaderIdᵖ ```go -func (m ShaderPtr_ShaderIdMap) Contains(key ShaderId) bool +type ShaderIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (ShaderPtr_ShaderIdMap) Delete +ShaderIdᵖ is a pointer to a ShaderId element. + +#### func NewShaderIdᵖ ```go -func (m ShaderPtr_ShaderIdMap) Delete(key ShaderId) +func NewShaderIdᵖ(addr memory.Pointer) ShaderIdᵖ ``` +NewShaderIdᵖ returns a ShaderIdᵖ that points to addr in the application pool. -#### func (ShaderPtr_ShaderIdMap) Get +#### func (*ShaderIdᵖ) Class ```go -func (m ShaderPtr_ShaderIdMap) Get(key ShaderId) *Shader +func (*ShaderIdᵖ) Class() binary.Class ``` -#### func (ShaderPtr_ShaderIdMap) Range +#### func (ShaderIdᵖ) ElementSize ```go -func (m ShaderPtr_ShaderIdMap) Range() []*Shader +func (p ShaderIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that ShaderIdᵖ points to. + +#### func (ShaderIdᵖ) Read + +```go +func (p ShaderIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) ShaderId +``` +Read reads and returns the ShaderId element at the pointer. + +#### func (ShaderIdᵖ) Slice + +```go +func (p ShaderIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderIdˢ +``` +Slice returns a new ShaderIdˢ from the pointer using start and end indices. + +#### func (ShaderIdᵖ) String + +```go +func (p ShaderIdᵖ) String() string +``` +String returns a string description of the ShaderIdᵖ pointer. + +#### func (ShaderIdᵖ) Write + +```go +func (p ShaderIdᵖ) Write(value ShaderId, ϟs *gfxapi.State) +``` +Write writes value to the ShaderId element at the pointer. + +#### type ShaderParameter + +```go +type ShaderParameter uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum ShaderParameter +////////////////////////////////////////////////////////////////////////////// + +#### func (*ShaderParameter) Parse + +```go +func (v *ShaderParameter) Parse(s string) error +``` + +#### func (ShaderParameter) String + +```go +func (v ShaderParameter) String() string ``` #### type ShaderType @@ -18401,12 +28043,49 @@ type ShaderType uint32 enum ShaderType ////////////////////////////////////////////////////////////////////////////// +#### func (*ShaderType) Parse + +```go +func (v *ShaderType) Parse(s string) error +``` + #### func (ShaderType) String ```go func (v ShaderType) String() string ``` +#### type ShaderTypeːShaderIdᵐ + +```go +type ShaderTypeːShaderIdᵐ map[ShaderType]ShaderId +``` + + +#### func (ShaderTypeːShaderIdᵐ) Contains + +```go +func (m ShaderTypeːShaderIdᵐ) Contains(key ShaderType) bool +``` + +#### func (ShaderTypeːShaderIdᵐ) Delete + +```go +func (m ShaderTypeːShaderIdᵐ) Delete(key ShaderType) +``` + +#### func (ShaderTypeːShaderIdᵐ) Get + +```go +func (m ShaderTypeːShaderIdᵐ) Get(key ShaderType) ShaderId +``` + +#### func (ShaderTypeːShaderIdᵐ) Range + +```go +func (m ShaderTypeːShaderIdᵐ) Range() []ShaderId +``` + #### type ShaderUniformType ```go @@ -18417,17 +28096,252 @@ type ShaderUniformType uint32 enum ShaderUniformType ////////////////////////////////////////////////////////////////////////////// +#### func (*ShaderUniformType) Parse + +```go +func (v *ShaderUniformType) Parse(s string) error +``` + #### func (ShaderUniformType) String ```go func (v ShaderUniformType) String() string ``` +#### type ShaderUniformTypeˢ + +```go +type ShaderUniformTypeˢ struct { + binary.Generate + SliceInfo +} +``` + +ShaderUniformTypeˢ is a slice of ShaderUniformType. + +#### func AsShaderUniformTypeˢ + +```go +func AsShaderUniformTypeˢ(s Slice, ϟs *gfxapi.State) ShaderUniformTypeˢ +``` +AsShaderUniformTypeˢ returns s cast to a ShaderUniformTypeˢ. The returned slice +length will be calculated so that the returned slice is no longer (in bytes) +than s. + +#### func MakeShaderUniformTypeˢ + +```go +func MakeShaderUniformTypeˢ(count uint64, ϟs *gfxapi.State) ShaderUniformTypeˢ +``` +MakeShaderUniformTypeˢ returns a ShaderUniformTypeˢ backed by a new memory pool. + +#### func (*ShaderUniformTypeˢ) Class + +```go +func (*ShaderUniformTypeˢ) Class() binary.Class +``` + +#### func (ShaderUniformTypeˢ) Clone + +```go +func (s ShaderUniformTypeˢ) Clone(ϟs *gfxapi.State) ShaderUniformTypeˢ +``` +Clone returns a copy of the ShaderUniformTypeˢ in a new memory pool. + +#### func (ShaderUniformTypeˢ) Copy + +```go +func (dst ShaderUniformTypeˢ) Copy(src ShaderUniformTypeˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s ShaderUniformTypeˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (ShaderUniformTypeˢ) Decoder + +```go +func (s ShaderUniformTypeˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (ShaderUniformTypeˢ) ElementSize + +```go +func (s ShaderUniformTypeˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that ShaderUniformTypeˢ +points to. + +#### func (ShaderUniformTypeˢ) Encoder + +```go +func (s ShaderUniformTypeˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (ShaderUniformTypeˢ) Index + +```go +func (s ShaderUniformTypeˢ) Index(i uint64, ϟs *gfxapi.State) ShaderUniformTypeᵖ +``` +Index returns a ShaderUniformTypeᵖ to the i'th element in this +ShaderUniformTypeˢ. + +#### func (ShaderUniformTypeˢ) Range + +```go +func (s ShaderUniformTypeˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (ShaderUniformTypeˢ) Read + +```go +func (s ShaderUniformTypeˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []ShaderUniformType +``` +Read reads and returns all the ShaderUniformType elements in this +ShaderUniformTypeˢ. + +#### func (ShaderUniformTypeˢ) ResourceID + +```go +func (s ShaderUniformTypeˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (ShaderUniformTypeˢ) Slice + +```go +func (s ShaderUniformTypeˢ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderUniformTypeˢ +``` +Slice returns a sub-slice from the ShaderUniformTypeˢ using start and end +indices. + +#### func (ShaderUniformTypeˢ) String + +```go +func (s ShaderUniformTypeˢ) String() string +``` +String returns a string description of the ShaderUniformTypeˢ slice. + +#### func (ShaderUniformTypeˢ) Write + +```go +func (dst ShaderUniformTypeˢ) Write(src []ShaderUniformType, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type ShaderUniformTypeᵖ + +```go +type ShaderUniformTypeᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +ShaderUniformTypeᵖ is a pointer to a ShaderUniformType element. + +#### func NewShaderUniformTypeᵖ + +```go +func NewShaderUniformTypeᵖ(addr memory.Pointer) ShaderUniformTypeᵖ +``` +NewShaderUniformTypeᵖ returns a ShaderUniformTypeᵖ that points to addr in the +application pool. + +#### func (*ShaderUniformTypeᵖ) Class + +```go +func (*ShaderUniformTypeᵖ) Class() binary.Class +``` + +#### func (ShaderUniformTypeᵖ) ElementSize + +```go +func (p ShaderUniformTypeᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that ShaderUniformTypeᵖ +points to. + +#### func (ShaderUniformTypeᵖ) Read + +```go +func (p ShaderUniformTypeᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) ShaderUniformType +``` +Read reads and returns the ShaderUniformType element at the pointer. + +#### func (ShaderUniformTypeᵖ) Slice + +```go +func (p ShaderUniformTypeᵖ) Slice(start, end uint64, ϟs *gfxapi.State) ShaderUniformTypeˢ +``` +Slice returns a new ShaderUniformTypeˢ from the pointer using start and end +indices. + +#### func (ShaderUniformTypeᵖ) String + +```go +func (p ShaderUniformTypeᵖ) String() string +``` +String returns a string description of the ShaderUniformTypeᵖ pointer. + +#### func (ShaderUniformTypeᵖ) Write + +```go +func (p ShaderUniformTypeᵖ) Write(value ShaderUniformType, ϟs *gfxapi.State) +``` +Write writes value to the ShaderUniformType element at the pointer. + +#### type Slice + +```go +type Slice interface { + // Info returns the SliceInfo of this slice. + Info() SliceInfo + // ElementSize returns the size in bytes of a single element in the slice. + ElementSize(ϟs *gfxapi.State) uint64 +} +``` + +Slice is the interface implemented by all slice types + +#### type SliceInfo + +```go +type SliceInfo struct { + binary.Generate + Root memory.Pointer // Original pointer this slice derives from. + Base memory.Pointer // Address of first element. + Count uint64 // Number of elements in the slice. + Pool memory.PoolID // Pool that holds the element data. +} +``` + +SliceInfo is the common data between all slice types. + +#### func (*SliceInfo) Class + +```go +func (*SliceInfo) Class() binary.Class +``` + +#### func (SliceInfo) Info + +```go +func (s SliceInfo) Info() SliceInfo +``` +Info returns the SliceInfo. It is used to conform to the Slice interface. + #### type StartTimer ```go type StartTimer struct { binary.Generate + Index uint8 } ``` @@ -18439,9 +28353,7 @@ StartTimer #### func NewStartTimer ```go -func NewStartTimer( - pIndex uint8, -) *StartTimer +func NewStartTimer(Index uint8) *StartTimer ``` #### func (*StartTimer) API @@ -18450,6 +28362,22 @@ func NewStartTimer( func (c *StartTimer) API() gfxapi.API ``` +#### func (*StartTimer) AddRead + +```go +func (a *StartTimer) AddRead(rng memory.Range, id binary.ID) *StartTimer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The StartTimer pointer is returned so that calls can be chained. + +#### func (*StartTimer) AddWrite + +```go +func (a *StartTimer) AddWrite(rng memory.Range, id binary.ID) *StartTimer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The StartTimer pointer is returned so that calls can be chained. + #### func (*StartTimer) Class ```go @@ -18465,19 +28393,25 @@ func (c *StartTimer) Flags() atom.Flags #### func (*StartTimer) Mutate ```go -func (ϟa *StartTimer) Mutate(ϟs *gfxapi.State) error +func (ϟa *StartTimer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*StartTimer) Observations + +```go +func (a *StartTimer) Observations() *atom.Observations ``` #### func (*StartTimer) Replay ```go -func (ϟa *StartTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *StartTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*StartTimer) String ```go -func (c *StartTimer) String() string +func (a *StartTimer) String() string ``` #### func (*StartTimer) TypeID @@ -18506,6 +28440,12 @@ type StateVariable uint32 enum StateVariable ////////////////////////////////////////////////////////////////////////////// +#### func (*StateVariable) Parse + +```go +func (v *StateVariable) Parse(s string) error +``` + #### func (StateVariable) String ```go @@ -18522,6 +28462,12 @@ type StateVariable_EXT_disjoint_timer_query uint32 enum StateVariable_EXT_disjoint_timer_query ////////////////////////////////////////////////////////////////////////////// +#### func (*StateVariable_EXT_disjoint_timer_query) Parse + +```go +func (v *StateVariable_EXT_disjoint_timer_query) Parse(s string) error +``` + #### func (StateVariable_EXT_disjoint_timer_query) String ```go @@ -18538,6 +28484,12 @@ type StateVariable_EXT_texture_filter_anisotropic uint32 enum StateVariable_EXT_texture_filter_anisotropic ////////////////////////////////////////////////////////////////////////////// +#### func (*StateVariable_EXT_texture_filter_anisotropic) Parse + +```go +func (v *StateVariable_EXT_texture_filter_anisotropic) Parse(s string) error +``` + #### func (StateVariable_EXT_texture_filter_anisotropic) String ```go @@ -18554,6 +28506,12 @@ type StateVariable_GLES_2_0 uint32 enum StateVariable_GLES_2_0 ////////////////////////////////////////////////////////////////////////////// +#### func (*StateVariable_GLES_2_0) Parse + +```go +func (v *StateVariable_GLES_2_0) Parse(s string) error +``` + #### func (StateVariable_GLES_2_0) String ```go @@ -18570,6 +28528,12 @@ type StateVariable_GLES_3_1 uint32 enum StateVariable_GLES_3_1 ////////////////////////////////////////////////////////////////////////////// +#### func (*StateVariable_GLES_3_1) Parse + +```go +func (v *StateVariable_GLES_3_1) Parse(s string) error +``` + #### func (StateVariable_GLES_3_1) String ```go @@ -18586,6 +28550,12 @@ type StencilAction uint32 enum StencilAction ////////////////////////////////////////////////////////////////////////////// +#### func (*StencilAction) Parse + +```go +func (v *StencilAction) Parse(s string) error +``` + #### func (StencilAction) String ```go @@ -18597,6 +28567,7 @@ func (v StencilAction) String() string ```go type StopTimer struct { binary.Generate + Index uint8 Result uint64 } @@ -18609,10 +28580,7 @@ StopTimer #### func NewStopTimer ```go -func NewStopTimer( - pIndex uint8, - pResult uint64, -) *StopTimer +func NewStopTimer(Index uint8, Result uint64) *StopTimer ``` #### func (*StopTimer) API @@ -18621,6 +28589,22 @@ func NewStopTimer( func (c *StopTimer) API() gfxapi.API ``` +#### func (*StopTimer) AddRead + +```go +func (a *StopTimer) AddRead(rng memory.Range, id binary.ID) *StopTimer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The StopTimer pointer is returned so that calls can be chained. + +#### func (*StopTimer) AddWrite + +```go +func (a *StopTimer) AddWrite(rng memory.Range, id binary.ID) *StopTimer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The StopTimer pointer is returned so that calls can be chained. + #### func (*StopTimer) Class ```go @@ -18636,19 +28620,25 @@ func (c *StopTimer) Flags() atom.Flags #### func (*StopTimer) Mutate ```go -func (ϟa *StopTimer) Mutate(ϟs *gfxapi.State) error +func (ϟa *StopTimer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*StopTimer) Observations + +```go +func (a *StopTimer) Observations() *atom.Observations ``` #### func (*StopTimer) Replay ```go -func (ϟa *StopTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *StopTimer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*StopTimer) String ```go -func (c *StopTimer) String() string +func (a *StopTimer) String() string ``` #### func (*StopTimer) TypeID @@ -18657,56 +28647,110 @@ func (c *StopTimer) String() string func (c *StopTimer) TypeID() atom.TypeID ``` -#### type StopTimer_Postback +#### type StringConstant ```go -type StopTimer_Postback struct { - Result uint64 -} +type StringConstant uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum StringConstant +////////////////////////////////////////////////////////////////////////////// -#### func (*StopTimer_Postback) Decode +#### func (*StringConstant) Parse ```go -func (o *StopTimer_Postback) Decode(d binary.Decoder) error +func (v *StringConstant) Parse(s string) error +``` + +#### func (StringConstant) String + +```go +func (v StringConstant) String() string ``` -#### type StringArray +#### type StringːAttributeLocationᵐ ```go -type StringArray []string +type StringːAttributeLocationᵐ map[string]AttributeLocation ``` -#### func (StringArray) Len +#### func (StringːAttributeLocationᵐ) Contains ```go -func (s StringArray) Len() int +func (m StringːAttributeLocationᵐ) Contains(key string) bool ``` -#### func (StringArray) Range +#### func (StringːAttributeLocationᵐ) Delete ```go -func (s StringArray) Range() []string +func (m StringːAttributeLocationᵐ) Delete(key string) ``` -#### type StringConstant +#### func (StringːAttributeLocationᵐ) Get ```go -type StringConstant uint32 +func (m StringːAttributeLocationᵐ) Get(key string) AttributeLocation +``` + +#### func (StringːAttributeLocationᵐ) Range + +```go +func (m StringːAttributeLocationᵐ) Range() []AttributeLocation +``` + +#### type SyncCondition + +```go +type SyncCondition uint32 ``` ////////////////////////////////////////////////////////////////////////////// -enum StringConstant +enum SyncCondition ////////////////////////////////////////////////////////////////////////////// -#### func (StringConstant) String +#### func (*SyncCondition) Parse ```go -func (v StringConstant) String() string +func (v *SyncCondition) Parse(s string) error +``` + +#### func (SyncCondition) String + +```go +func (v SyncCondition) String() string ``` +#### type SyncFlags + +```go +type SyncFlags uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum SyncFlags +////////////////////////////////////////////////////////////////////////////// + +#### func (*SyncFlags) Parse + +```go +func (v *SyncFlags) Parse(s string) error +``` + +#### func (SyncFlags) String + +```go +func (v SyncFlags) String() string +``` + +#### type SyncObject + +```go +type SyncObject uint64 +``` + + #### type TestFunction ```go @@ -18717,6 +28761,12 @@ type TestFunction uint32 enum TestFunction ////////////////////////////////////////////////////////////////////////////// +#### func (*TestFunction) Parse + +```go +func (v *TestFunction) Parse(s string) error +``` + #### func (TestFunction) String ```go @@ -18733,6 +28783,12 @@ type TexelComponent uint32 enum TexelComponent ////////////////////////////////////////////////////////////////////////////// +#### func (*TexelComponent) Parse + +```go +func (v *TexelComponent) Parse(s string) error +``` + #### func (TexelComponent) String ```go @@ -18749,6 +28805,12 @@ type TexelFormat uint32 enum TexelFormat ////////////////////////////////////////////////////////////////////////////// +#### func (*TexelFormat) Parse + +```go +func (v *TexelFormat) Parse(s string) error +``` + #### func (TexelFormat) String ```go @@ -18765,6 +28827,12 @@ type TexelFormat_GLES_1_1 uint32 enum TexelFormat_GLES_1_1 ////////////////////////////////////////////////////////////////////////////// +#### func (*TexelFormat_GLES_1_1) Parse + +```go +func (v *TexelFormat_GLES_1_1) Parse(s string) error +``` + #### func (TexelFormat_GLES_1_1) String ```go @@ -18781,6 +28849,12 @@ type TexelFormat_GLES_3_0 uint32 enum TexelFormat_GLES_3_0 ////////////////////////////////////////////////////////////////////////////// +#### func (*TexelFormat_GLES_3_0) Parse + +```go +func (v *TexelFormat_GLES_3_0) Parse(s string) error +``` + #### func (TexelFormat_GLES_3_0) String ```go @@ -18797,6 +28871,12 @@ type TexelType uint32 enum TexelType ////////////////////////////////////////////////////////////////////////////// +#### func (*TexelType) Parse + +```go +func (v *TexelType) Parse(s string) error +``` + #### func (TexelType) String ```go @@ -18811,8 +28891,8 @@ type Texture struct { CreatedAt atom.ID Kind TextureKind Format ImageTexelFormat - Texture2D Image_s32Map - Cubemap CubemapLevel_s32Map + Texture2D S32ːImageᵐ + Cubemap S32ːCubemapLevelᵐ MagFilter TextureFilterMode MinFilter TextureFilterMode WrapS TextureWrapMode @@ -18857,146 +28937,257 @@ type Texture2DImageTarget uint32 enum Texture2DImageTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*Texture2DImageTarget) Parse + +```go +func (v *Texture2DImageTarget) Parse(s string) error +``` + #### func (Texture2DImageTarget) String ```go func (v Texture2DImageTarget) String() string ``` -#### type TextureArray +#### type TextureFilterMode ```go -type TextureArray []Texture +type TextureFilterMode uint32 ``` +////////////////////////////////////////////////////////////////////////////// +enum TextureFilterMode +////////////////////////////////////////////////////////////////////////////// -#### func (TextureArray) Len +#### func (*TextureFilterMode) Parse ```go -func (s TextureArray) Len() int +func (v *TextureFilterMode) Parse(s string) error ``` -#### func (TextureArray) Range +#### func (TextureFilterMode) String ```go -func (s TextureArray) Range() []Texture +func (v TextureFilterMode) String() string ``` -#### type TextureFilterMode +#### type TextureId ```go -type TextureFilterMode uint32 +type TextureId uint32 ``` -////////////////////////////////////////////////////////////////////////////// -enum TextureFilterMode -////////////////////////////////////////////////////////////////////////////// -#### func (TextureFilterMode) String +#### type TextureIdːTextureʳᵐ ```go -func (v TextureFilterMode) String() string +type TextureIdːTextureʳᵐ map[TextureId](*Texture) ``` -#### type TextureId + +#### func (TextureIdːTextureʳᵐ) Contains ```go -type TextureId uint32 +func (m TextureIdːTextureʳᵐ) Contains(key TextureId) bool ``` +#### func (TextureIdːTextureʳᵐ) Delete + +```go +func (m TextureIdːTextureʳᵐ) Delete(key TextureId) +``` -#### func (*TextureId) Equal +#### func (TextureIdːTextureʳᵐ) Get ```go -func (c *TextureId) Equal(rhs TextureId) bool +func (m TextureIdːTextureʳᵐ) Get(key TextureId) *Texture ``` -#### func (*TextureId) Less +#### func (TextureIdːTextureʳᵐ) Range ```go -func (c *TextureId) Less(rhs TextureId) bool +func (m TextureIdːTextureʳᵐ) Range() [](*Texture) ``` -#### type TextureIdArray +#### type TextureIdˢ ```go -type TextureIdArray []TextureId +type TextureIdˢ struct { + binary.Generate + SliceInfo +} ``` +TextureIdˢ is a slice of TextureId. -#### func (TextureIdArray) Len +#### func AsTextureIdˢ ```go -func (s TextureIdArray) Len() int +func AsTextureIdˢ(s Slice, ϟs *gfxapi.State) TextureIdˢ ``` +AsTextureIdˢ returns s cast to a TextureIdˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### func (TextureIdArray) Range +#### func MakeTextureIdˢ ```go -func (s TextureIdArray) Range() []TextureId +func MakeTextureIdˢ(count uint64, ϟs *gfxapi.State) TextureIdˢ ``` +MakeTextureIdˢ returns a TextureIdˢ backed by a new memory pool. -#### type TextureId_TextureTargetMap +#### func (*TextureIdˢ) Class ```go -type TextureId_TextureTargetMap map[TextureTarget]TextureId +func (*TextureIdˢ) Class() binary.Class ``` +#### func (TextureIdˢ) Clone -#### func (TextureId_TextureTargetMap) Contains +```go +func (s TextureIdˢ) Clone(ϟs *gfxapi.State) TextureIdˢ +``` +Clone returns a copy of the TextureIdˢ in a new memory pool. + +#### func (TextureIdˢ) Copy ```go -func (m TextureId_TextureTargetMap) Contains(key TextureTarget) bool +func (dst TextureIdˢ) Copy(src TextureIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s TextureIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (TextureId_TextureTargetMap) Delete +#### func (TextureIdˢ) Decoder ```go -func (m TextureId_TextureTargetMap) Delete(key TextureTarget) +func (s TextureIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (TextureId_TextureTargetMap) Get +#### func (TextureIdˢ) ElementSize ```go -func (m TextureId_TextureTargetMap) Get(key TextureTarget) TextureId +func (s TextureIdˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that TextureIdˢ points to. -#### func (TextureId_TextureTargetMap) Range +#### func (TextureIdˢ) Encoder ```go -func (m TextureId_TextureTargetMap) Range() []TextureId +func (s TextureIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### type TextureId_TextureTargetMap_TextureUnitMap +#### func (TextureIdˢ) Index ```go -type TextureId_TextureTargetMap_TextureUnitMap map[TextureUnit]TextureId_TextureTargetMap +func (s TextureIdˢ) Index(i uint64, ϟs *gfxapi.State) TextureIdᵖ ``` +Index returns a TextureIdᵖ to the i'th element in this TextureIdˢ. + +#### func (TextureIdˢ) Range +```go +func (s TextureIdˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. -#### func (TextureId_TextureTargetMap_TextureUnitMap) Contains +#### func (TextureIdˢ) Read ```go -func (m TextureId_TextureTargetMap_TextureUnitMap) Contains(key TextureUnit) bool +func (s TextureIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []TextureId ``` +Read reads and returns all the TextureId elements in this TextureIdˢ. -#### func (TextureId_TextureTargetMap_TextureUnitMap) Delete +#### func (TextureIdˢ) ResourceID ```go -func (m TextureId_TextureTargetMap_TextureUnitMap) Delete(key TextureUnit) +func (s TextureIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### func (TextureId_TextureTargetMap_TextureUnitMap) Get +#### func (TextureIdˢ) Slice ```go -func (m TextureId_TextureTargetMap_TextureUnitMap) Get(key TextureUnit) TextureId_TextureTargetMap +func (s TextureIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) TextureIdˢ ``` +Slice returns a sub-slice from the TextureIdˢ using start and end indices. -#### func (TextureId_TextureTargetMap_TextureUnitMap) Range +#### func (TextureIdˢ) String ```go -func (m TextureId_TextureTargetMap_TextureUnitMap) Range() []TextureId_TextureTargetMap +func (s TextureIdˢ) String() string ``` +String returns a string description of the TextureIdˢ slice. + +#### func (TextureIdˢ) Write + +```go +func (dst TextureIdˢ) Write(src []TextureId, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type TextureIdᵖ + +```go +type TextureIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +TextureIdᵖ is a pointer to a TextureId element. + +#### func NewTextureIdᵖ + +```go +func NewTextureIdᵖ(addr memory.Pointer) TextureIdᵖ +``` +NewTextureIdᵖ returns a TextureIdᵖ that points to addr in the application pool. + +#### func (*TextureIdᵖ) Class + +```go +func (*TextureIdᵖ) Class() binary.Class +``` + +#### func (TextureIdᵖ) ElementSize + +```go +func (p TextureIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that TextureIdᵖ points to. + +#### func (TextureIdᵖ) Read + +```go +func (p TextureIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) TextureId +``` +Read reads and returns the TextureId element at the pointer. + +#### func (TextureIdᵖ) Slice + +```go +func (p TextureIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) TextureIdˢ +``` +Slice returns a new TextureIdˢ from the pointer using start and end indices. + +#### func (TextureIdᵖ) String + +```go +func (p TextureIdᵖ) String() string +``` +String returns a string description of the TextureIdᵖ pointer. + +#### func (TextureIdᵖ) Write + +```go +func (p TextureIdᵖ) Write(value TextureId, ϟs *gfxapi.State) +``` +Write writes value to the TextureId element at the pointer. #### type TextureImageTarget @@ -19008,6 +29199,12 @@ type TextureImageTarget uint32 enum TextureImageTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureImageTarget) Parse + +```go +func (v *TextureImageTarget) Parse(s string) error +``` + #### func (TextureImageTarget) String ```go @@ -19024,6 +29221,12 @@ type TextureKind uint32 enum TextureKind ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureKind) Parse + +```go +func (v *TextureKind) Parse(s string) error +``` + #### func (TextureKind) String ```go @@ -19040,6 +29243,12 @@ type TextureParameter uint32 enum TextureParameter ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureParameter) Parse + +```go +func (v *TextureParameter) Parse(s string) error +``` + #### func (TextureParameter) String ```go @@ -19056,6 +29265,12 @@ type TextureParameter_EXT_texture_filter_anisotropic uint32 enum TextureParameter_EXT_texture_filter_anisotropic ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureParameter_EXT_texture_filter_anisotropic) Parse + +```go +func (v *TextureParameter_EXT_texture_filter_anisotropic) Parse(s string) error +``` + #### func (TextureParameter_EXT_texture_filter_anisotropic) String ```go @@ -19072,6 +29287,12 @@ type TextureParameter_FilterMode uint32 enum TextureParameter_FilterMode ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureParameter_FilterMode) Parse + +```go +func (v *TextureParameter_FilterMode) Parse(s string) error +``` + #### func (TextureParameter_FilterMode) String ```go @@ -19088,6 +29309,12 @@ type TextureParameter_SwizzleMode uint32 enum TextureParameter_SwizzleMode ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureParameter_SwizzleMode) Parse + +```go +func (v *TextureParameter_SwizzleMode) Parse(s string) error +``` + #### func (TextureParameter_SwizzleMode) String ```go @@ -19104,61 +29331,65 @@ type TextureParameter_WrapMode uint32 enum TextureParameter_WrapMode ////////////////////////////////////////////////////////////////////////////// -#### func (TextureParameter_WrapMode) String +#### func (*TextureParameter_WrapMode) Parse ```go -func (v TextureParameter_WrapMode) String() string +func (v *TextureParameter_WrapMode) Parse(s string) error ``` -#### type TexturePointer +#### func (TextureParameter_WrapMode) String ```go -type TexturePointer memory.Pointer +func (v TextureParameter_WrapMode) String() string ``` - -#### func (*TexturePointer) Equal +#### type TexturePointer ```go -func (c *TexturePointer) Equal(rhs TexturePointer) bool +type TexturePointer struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (*TexturePointer) Less +TexturePointer is a pointer to a void element. -```go -func (c *TexturePointer) Less(rhs TexturePointer) bool -``` - -#### type TexturePtr_TextureIdMap +#### func NewTexturePointer ```go -type TexturePtr_TextureIdMap map[TextureId]*Texture +func NewTexturePointer(addr memory.Pointer) TexturePointer ``` +NewTexturePointer returns a TexturePointer that points to addr in the +application pool. - -#### func (TexturePtr_TextureIdMap) Contains +#### func (*TexturePointer) Class ```go -func (m TexturePtr_TextureIdMap) Contains(key TextureId) bool +func (*TexturePointer) Class() binary.Class ``` -#### func (TexturePtr_TextureIdMap) Delete +#### func (TexturePointer) ElementSize ```go -func (m TexturePtr_TextureIdMap) Delete(key TextureId) +func (p TexturePointer) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that TexturePointer points +to. -#### func (TexturePtr_TextureIdMap) Get +#### func (TexturePointer) Slice ```go -func (m TexturePtr_TextureIdMap) Get(key TextureId) *Texture +func (p TexturePointer) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (TexturePtr_TextureIdMap) Range +#### func (TexturePointer) String ```go -func (m TexturePtr_TextureIdMap) Range() []*Texture +func (p TexturePointer) String() string ``` +String returns a string description of the TexturePointer pointer. #### type TextureTarget @@ -19170,6 +29401,12 @@ type TextureTarget uint32 enum TextureTarget ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureTarget) Parse + +```go +func (v *TextureTarget) Parse(s string) error +``` + #### func (TextureTarget) String ```go @@ -19186,6 +29423,12 @@ type TextureTarget_GLES_1_1 uint32 enum TextureTarget_GLES_1_1 ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureTarget_GLES_1_1) Parse + +```go +func (v *TextureTarget_GLES_1_1) Parse(s string) error +``` + #### func (TextureTarget_GLES_1_1) String ```go @@ -19202,6 +29445,12 @@ type TextureTarget_GLES_2_0 uint32 enum TextureTarget_GLES_2_0 ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureTarget_GLES_2_0) Parse + +```go +func (v *TextureTarget_GLES_2_0) Parse(s string) error +``` + #### func (TextureTarget_GLES_2_0) String ```go @@ -19218,12 +29467,49 @@ type TextureTarget_OES_EGL_image_external uint32 enum TextureTarget_OES_EGL_image_external ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureTarget_OES_EGL_image_external) Parse + +```go +func (v *TextureTarget_OES_EGL_image_external) Parse(s string) error +``` + #### func (TextureTarget_OES_EGL_image_external) String ```go func (v TextureTarget_OES_EGL_image_external) String() string ``` +#### type TextureTargetːTextureIdᵐ + +```go +type TextureTargetːTextureIdᵐ map[TextureTarget]TextureId +``` + + +#### func (TextureTargetːTextureIdᵐ) Contains + +```go +func (m TextureTargetːTextureIdᵐ) Contains(key TextureTarget) bool +``` + +#### func (TextureTargetːTextureIdᵐ) Delete + +```go +func (m TextureTargetːTextureIdᵐ) Delete(key TextureTarget) +``` + +#### func (TextureTargetːTextureIdᵐ) Get + +```go +func (m TextureTargetːTextureIdᵐ) Get(key TextureTarget) TextureId +``` + +#### func (TextureTargetːTextureIdᵐ) Range + +```go +func (m TextureTargetːTextureIdᵐ) Range() []TextureId +``` + #### type TextureUnit ```go @@ -19234,12 +29520,49 @@ type TextureUnit uint32 enum TextureUnit ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureUnit) Parse + +```go +func (v *TextureUnit) Parse(s string) error +``` + #### func (TextureUnit) String ```go func (v TextureUnit) String() string ``` +#### type TextureUnitːTextureTargetːTextureIdᵐᵐ + +```go +type TextureUnitːTextureTargetːTextureIdᵐᵐ map[TextureUnit]TextureTargetːTextureIdᵐ +``` + + +#### func (TextureUnitːTextureTargetːTextureIdᵐᵐ) Contains + +```go +func (m TextureUnitːTextureTargetːTextureIdᵐᵐ) Contains(key TextureUnit) bool +``` + +#### func (TextureUnitːTextureTargetːTextureIdᵐᵐ) Delete + +```go +func (m TextureUnitːTextureTargetːTextureIdᵐᵐ) Delete(key TextureUnit) +``` + +#### func (TextureUnitːTextureTargetːTextureIdᵐᵐ) Get + +```go +func (m TextureUnitːTextureTargetːTextureIdᵐᵐ) Get(key TextureUnit) TextureTargetːTextureIdᵐ +``` + +#### func (TextureUnitːTextureTargetːTextureIdᵐᵐ) Range + +```go +func (m TextureUnitːTextureTargetːTextureIdᵐᵐ) Range() []TextureTargetːTextureIdᵐ +``` + #### type TextureWrapMode ```go @@ -19250,6 +29573,12 @@ type TextureWrapMode uint32 enum TextureWrapMode ////////////////////////////////////////////////////////////////////////////// +#### func (*TextureWrapMode) Parse + +```go +func (v *TextureWrapMode) Parse(s string) error +``` + #### func (TextureWrapMode) String ```go @@ -19263,16 +29592,35 @@ type ThreadID uint32 ``` -#### func (*ThreadID) Equal +#### type ThreadIDːContextʳᵐ + +```go +type ThreadIDːContextʳᵐ map[ThreadID](*Context) +``` + + +#### func (ThreadIDːContextʳᵐ) Contains + +```go +func (m ThreadIDːContextʳᵐ) Contains(key ThreadID) bool +``` + +#### func (ThreadIDːContextʳᵐ) Delete + +```go +func (m ThreadIDːContextʳᵐ) Delete(key ThreadID) +``` + +#### func (ThreadIDːContextʳᵐ) Get ```go -func (c *ThreadID) Equal(rhs ThreadID) bool +func (m ThreadIDːContextʳᵐ) Get(key ThreadID) *Context ``` -#### func (*ThreadID) Less +#### func (ThreadIDːContextʳᵐ) Range ```go -func (c *ThreadID) Less(rhs ThreadID) bool +func (m ThreadIDːContextʳᵐ) Range() [](*Context) ``` #### type TilePreserveMaskQCOM @@ -19285,6 +29633,12 @@ type TilePreserveMaskQCOM uint32 enum TilePreserveMaskQCOM ////////////////////////////////////////////////////////////////////////////// +#### func (*TilePreserveMaskQCOM) Parse + +```go +func (v *TilePreserveMaskQCOM) Parse(s string) error +``` + #### func (TilePreserveMaskQCOM) String ```go @@ -19301,6 +29655,12 @@ type Type_ARB_half_float_vertex uint32 enum Type_ARB_half_float_vertex ////////////////////////////////////////////////////////////////////////////// +#### func (*Type_ARB_half_float_vertex) Parse + +```go +func (v *Type_ARB_half_float_vertex) Parse(s string) error +``` + #### func (Type_ARB_half_float_vertex) String ```go @@ -19317,42 +29677,557 @@ type Type_OES_vertex_half_float uint32 enum Type_OES_vertex_half_float ////////////////////////////////////////////////////////////////////////////// +#### func (*Type_OES_vertex_half_float) Parse + +```go +func (v *Type_OES_vertex_half_float) Parse(s string) error +``` + #### func (Type_OES_vertex_half_float) String ```go func (v Type_OES_vertex_half_float) String() string ``` -#### type U32_FaceModeMap +#### type U32ˢ + +```go +type U32ˢ struct { + binary.Generate + SliceInfo +} +``` + +U32ˢ is a slice of uint32. + +#### func AsU32ˢ ```go -type U32_FaceModeMap map[FaceMode]uint32 +func AsU32ˢ(s Slice, ϟs *gfxapi.State) U32ˢ ``` +AsU32ˢ returns s cast to a U32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU32ˢ +```go +func MakeU32ˢ(count uint64, ϟs *gfxapi.State) U32ˢ +``` +MakeU32ˢ returns a U32ˢ backed by a new memory pool. + +#### func (*U32ˢ) Class + +```go +func (*U32ˢ) Class() binary.Class +``` + +#### func (U32ˢ) Clone + +```go +func (s U32ˢ) Clone(ϟs *gfxapi.State) U32ˢ +``` +Clone returns a copy of the U32ˢ in a new memory pool. + +#### func (U32ˢ) Copy + +```go +func (dst U32ˢ) Copy(src U32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (U32_FaceModeMap) Contains +#### func (U32ˢ) Decoder ```go -func (m U32_FaceModeMap) Contains(key FaceMode) bool +func (s U32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (U32_FaceModeMap) Delete +#### func (U32ˢ) ElementSize ```go -func (m U32_FaceModeMap) Delete(key FaceMode) +func (s U32ˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that U32ˢ points to. -#### func (U32_FaceModeMap) Get +#### func (U32ˢ) Encoder ```go -func (m U32_FaceModeMap) Get(key FaceMode) uint32 +func (s U32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (U32_FaceModeMap) Range +#### func (U32ˢ) Index ```go -func (m U32_FaceModeMap) Range() []uint32 +func (s U32ˢ) Index(i uint64, ϟs *gfxapi.State) U32ᵖ ``` +Index returns a U32ᵖ to the i'th element in this U32ˢ. + +#### func (U32ˢ) Range + +```go +func (s U32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U32ˢ) Read + +```go +func (s U32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint32 +``` +Read reads and returns all the uint32 elements in this U32ˢ. + +#### func (U32ˢ) ResourceID + +```go +func (s U32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U32ˢ) Slice + +```go +func (s U32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U32ˢ +``` +Slice returns a sub-slice from the U32ˢ using start and end indices. + +#### func (U32ˢ) String + +```go +func (s U32ˢ) String() string +``` +String returns a string description of the U32ˢ slice. + +#### func (U32ˢ) Write + +```go +func (dst U32ˢ) Write(src []uint32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U32ᵖ + +```go +type U32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U32ᵖ is a pointer to a uint32 element. + +#### func NewU32ᵖ + +```go +func NewU32ᵖ(addr memory.Pointer) U32ᵖ +``` +NewU32ᵖ returns a U32ᵖ that points to addr in the application pool. + +#### func (*U32ᵖ) Class + +```go +func (*U32ᵖ) Class() binary.Class +``` + +#### func (U32ᵖ) ElementSize + +```go +func (p U32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U32ᵖ points to. + +#### func (U32ᵖ) Read + +```go +func (p U32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint32 +``` +Read reads and returns the uint32 element at the pointer. + +#### func (U32ᵖ) Slice + +```go +func (p U32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U32ˢ +``` +Slice returns a new U32ˢ from the pointer using start and end indices. + +#### func (U32ᵖ) String + +```go +func (p U32ᵖ) String() string +``` +String returns a string description of the U32ᵖ pointer. + +#### func (U32ᵖ) Write + +```go +func (p U32ᵖ) Write(value uint32, ϟs *gfxapi.State) +``` +Write writes value to the uint32 element at the pointer. + +#### type U64ˢ + +```go +type U64ˢ struct { + binary.Generate + SliceInfo +} +``` + +U64ˢ is a slice of uint64. + +#### func AsU64ˢ + +```go +func AsU64ˢ(s Slice, ϟs *gfxapi.State) U64ˢ +``` +AsU64ˢ returns s cast to a U64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU64ˢ + +```go +func MakeU64ˢ(count uint64, ϟs *gfxapi.State) U64ˢ +``` +MakeU64ˢ returns a U64ˢ backed by a new memory pool. + +#### func (*U64ˢ) Class + +```go +func (*U64ˢ) Class() binary.Class +``` + +#### func (U64ˢ) Clone + +```go +func (s U64ˢ) Clone(ϟs *gfxapi.State) U64ˢ +``` +Clone returns a copy of the U64ˢ in a new memory pool. + +#### func (U64ˢ) Copy + +```go +func (dst U64ˢ) Copy(src U64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U64ˢ) Decoder + +```go +func (s U64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U64ˢ) ElementSize + +```go +func (s U64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U64ˢ points to. + +#### func (U64ˢ) Encoder + +```go +func (s U64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U64ˢ) Index + +```go +func (s U64ˢ) Index(i uint64, ϟs *gfxapi.State) U64ᵖ +``` +Index returns a U64ᵖ to the i'th element in this U64ˢ. + +#### func (U64ˢ) Range + +```go +func (s U64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U64ˢ) Read + +```go +func (s U64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint64 +``` +Read reads and returns all the uint64 elements in this U64ˢ. + +#### func (U64ˢ) ResourceID + +```go +func (s U64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U64ˢ) Slice + +```go +func (s U64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U64ˢ +``` +Slice returns a sub-slice from the U64ˢ using start and end indices. + +#### func (U64ˢ) String + +```go +func (s U64ˢ) String() string +``` +String returns a string description of the U64ˢ slice. + +#### func (U64ˢ) Write + +```go +func (dst U64ˢ) Write(src []uint64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U64ᵖ + +```go +type U64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U64ᵖ is a pointer to a uint64 element. + +#### func NewU64ᵖ + +```go +func NewU64ᵖ(addr memory.Pointer) U64ᵖ +``` +NewU64ᵖ returns a U64ᵖ that points to addr in the application pool. + +#### func (*U64ᵖ) Class + +```go +func (*U64ᵖ) Class() binary.Class +``` + +#### func (U64ᵖ) ElementSize + +```go +func (p U64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U64ᵖ points to. + +#### func (U64ᵖ) Read + +```go +func (p U64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint64 +``` +Read reads and returns the uint64 element at the pointer. + +#### func (U64ᵖ) Slice + +```go +func (p U64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U64ˢ +``` +Slice returns a new U64ˢ from the pointer using start and end indices. + +#### func (U64ᵖ) String + +```go +func (p U64ᵖ) String() string +``` +String returns a string description of the U64ᵖ pointer. + +#### func (U64ᵖ) Write + +```go +func (p U64ᵖ) Write(value uint64, ϟs *gfxapi.State) +``` +Write writes value to the uint64 element at the pointer. + +#### type U8ˢ + +```go +type U8ˢ struct { + binary.Generate + SliceInfo +} +``` + +U8ˢ is a slice of uint8. + +#### func AsU8ˢ + +```go +func AsU8ˢ(s Slice, ϟs *gfxapi.State) U8ˢ +``` +AsU8ˢ returns s cast to a U8ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU8ˢ + +```go +func MakeU8ˢ(count uint64, ϟs *gfxapi.State) U8ˢ +``` +MakeU8ˢ returns a U8ˢ backed by a new memory pool. + +#### func (*U8ˢ) Class + +```go +func (*U8ˢ) Class() binary.Class +``` + +#### func (U8ˢ) Clone + +```go +func (s U8ˢ) Clone(ϟs *gfxapi.State) U8ˢ +``` +Clone returns a copy of the U8ˢ in a new memory pool. + +#### func (U8ˢ) Copy + +```go +func (dst U8ˢ) Copy(src U8ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U8ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U8ˢ) Decoder + +```go +func (s U8ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U8ˢ) ElementSize + +```go +func (s U8ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U8ˢ points to. + +#### func (U8ˢ) Encoder + +```go +func (s U8ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U8ˢ) Index + +```go +func (s U8ˢ) Index(i uint64, ϟs *gfxapi.State) U8ᵖ +``` +Index returns a U8ᵖ to the i'th element in this U8ˢ. + +#### func (U8ˢ) Range + +```go +func (s U8ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U8ˢ) Read + +```go +func (s U8ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint8 +``` +Read reads and returns all the uint8 elements in this U8ˢ. + +#### func (U8ˢ) ResourceID + +```go +func (s U8ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U8ˢ) Slice + +```go +func (s U8ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U8ˢ +``` +Slice returns a sub-slice from the U8ˢ using start and end indices. + +#### func (U8ˢ) String + +```go +func (s U8ˢ) String() string +``` +String returns a string description of the U8ˢ slice. + +#### func (U8ˢ) Write + +```go +func (dst U8ˢ) Write(src []uint8, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U8ᵖ + +```go +type U8ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U8ᵖ is a pointer to a uint8 element. + +#### func NewU8ᵖ + +```go +func NewU8ᵖ(addr memory.Pointer) U8ᵖ +``` +NewU8ᵖ returns a U8ᵖ that points to addr in the application pool. + +#### func (*U8ᵖ) Class + +```go +func (*U8ᵖ) Class() binary.Class +``` + +#### func (U8ᵖ) ElementSize + +```go +func (p U8ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U8ᵖ points to. + +#### func (U8ᵖ) Read + +```go +func (p U8ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint8 +``` +Read reads and returns the uint8 element at the pointer. + +#### func (U8ᵖ) Slice + +```go +func (p U8ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U8ˢ +``` +Slice returns a new U8ˢ from the pointer using start and end indices. + +#### func (U8ᵖ) String + +```go +func (p U8ᵖ) String() string +``` +String returns a string description of the U8ᵖ pointer. + +#### func (U8ᵖ) Write + +```go +func (p U8ᵖ) Write(value uint8, ϟs *gfxapi.State) +``` +Write writes value to the uint8 element at the pointer. #### type Uniform @@ -19362,7 +30237,7 @@ type Uniform struct { CreatedAt atom.ID Name string Type ShaderUniformType - Value UniformValue + Value U8ˢ } ``` @@ -19388,10 +30263,26 @@ func (c *Uniform) GetCreatedAt() atom.ID func (c *Uniform) Init() ``` -#### func (Uniform) String +#### type UniformBlockParameter ```go -func (u Uniform) String() string +type UniformBlockParameter uint32 +``` + +////////////////////////////////////////////////////////////////////////////// +enum UniformBlockParameter +////////////////////////////////////////////////////////////////////////////// + +#### func (*UniformBlockParameter) Parse + +```go +func (v *UniformBlockParameter) Parse(s string) error +``` + +#### func (UniformBlockParameter) String + +```go +func (v UniformBlockParameter) String() string ``` #### type UniformLocation @@ -19401,144 +30292,258 @@ type UniformLocation int32 ``` -#### func (*UniformLocation) Equal +#### type UniformLocationːUniformᵐ + +```go +type UniformLocationːUniformᵐ map[UniformLocation]Uniform +``` + + +#### func (UniformLocationːUniformᵐ) Contains + +```go +func (m UniformLocationːUniformᵐ) Contains(key UniformLocation) bool +``` + +#### func (UniformLocationːUniformᵐ) Delete + +```go +func (m UniformLocationːUniformᵐ) Delete(key UniformLocation) +``` + +#### func (UniformLocationːUniformᵐ) Get + +```go +func (m UniformLocationːUniformᵐ) Get(key UniformLocation) Uniform +``` + +#### func (UniformLocationːUniformᵐ) Range ```go -func (c *UniformLocation) Equal(rhs UniformLocation) bool +func (m UniformLocationːUniformᵐ) Range() []Uniform ``` -#### func (*UniformLocation) Less +#### type Vec2f ```go -func (c *UniformLocation) Less(rhs UniformLocation) bool +type Vec2f F32ː2ᵃ ``` -#### type UniformValue + +#### func (*Vec2f) Class ```go -type UniformValue struct { +func (*Vec2f) Class() binary.Class +``` + +#### func (Vec2f) String + +```go +func (v Vec2f) String() string +``` + +#### type Vec2fː2ᵃ + +```go +type Vec2fː2ᵃ struct { binary.Generate - CreatedAt atom.ID - F32 float32 - Vec2f Vec2f - Vec3f Vec3f - Vec4f Vec4f - S32 int32 - Vec2i Vec2i - Vec3i Vec3i - Vec4i Vec4i - Mat2f Mat2f - Mat3f Mat3f - Mat4f Mat4f + Elements [2]Vec2f } ``` -////////////////////////////////////////////////////////////////////////////// -class UniformValue -////////////////////////////////////////////////////////////////////////////// -#### func (*UniformValue) Class +#### func (*Vec2fː2ᵃ) Class ```go -func (*UniformValue) Class() binary.Class +func (*Vec2fː2ᵃ) Class() binary.Class ``` -#### func (*UniformValue) GetCreatedAt +#### type Vec2fˢ ```go -func (c *UniformValue) GetCreatedAt() atom.ID +type Vec2fˢ struct { + binary.Generate + SliceInfo +} ``` -#### func (*UniformValue) Init +Vec2fˢ is a slice of Vec2f. + +#### func AsVec2fˢ ```go -func (c *UniformValue) Init() +func AsVec2fˢ(s Slice, ϟs *gfxapi.State) Vec2fˢ ``` +AsVec2fˢ returns s cast to a Vec2fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### type Uniform_UniformLocationMap +#### func MakeVec2fˢ ```go -type Uniform_UniformLocationMap map[UniformLocation]Uniform +func MakeVec2fˢ(count uint64, ϟs *gfxapi.State) Vec2fˢ ``` +MakeVec2fˢ returns a Vec2fˢ backed by a new memory pool. +#### func (*Vec2fˢ) Class -#### func (Uniform_UniformLocationMap) Contains +```go +func (*Vec2fˢ) Class() binary.Class +``` + +#### func (Vec2fˢ) Clone ```go -func (m Uniform_UniformLocationMap) Contains(key UniformLocation) bool +func (s Vec2fˢ) Clone(ϟs *gfxapi.State) Vec2fˢ ``` +Clone returns a copy of the Vec2fˢ in a new memory pool. -#### func (Uniform_UniformLocationMap) Delete +#### func (Vec2fˢ) Copy ```go -func (m Uniform_UniformLocationMap) Delete(key UniformLocation) +func (dst Vec2fˢ) Copy(src Vec2fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec2fˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (Uniform_UniformLocationMap) Get +#### func (Vec2fˢ) Decoder ```go -func (m Uniform_UniformLocationMap) Get(key UniformLocation) Uniform +func (s Vec2fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (Uniform_UniformLocationMap) Range +#### func (Vec2fˢ) ElementSize ```go -func (m Uniform_UniformLocationMap) Range() []Uniform +func (s Vec2fˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Vec2fˢ points to. -#### type Vec2f +#### func (Vec2fˢ) Encoder + +```go +func (s Vec2fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec2fˢ) Index + +```go +func (s Vec2fˢ) Index(i uint64, ϟs *gfxapi.State) Vec2fᵖ +``` +Index returns a Vec2fᵖ to the i'th element in this Vec2fˢ. + +#### func (Vec2fˢ) Range + +```go +func (s Vec2fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec2fˢ) Read + +```go +func (s Vec2fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec2f +``` +Read reads and returns all the Vec2f elements in this Vec2fˢ. + +#### func (Vec2fˢ) ResourceID + +```go +func (s Vec2fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Vec2fˢ) Slice + +```go +func (s Vec2fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec2fˢ +``` +Slice returns a sub-slice from the Vec2fˢ using start and end indices. + +#### func (Vec2fˢ) String + +```go +func (s Vec2fˢ) String() string +``` +String returns a string description of the Vec2fˢ slice. + +#### func (Vec2fˢ) Write + +```go +func (dst Vec2fˢ) Write(src []Vec2f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec2fᵖ ```go -type Vec2f struct { +type Vec2fᵖ struct { binary.Generate - CreatedAt atom.ID - X float32 - Y float32 + Address memory.Pointer + Pool memory.PoolID } ``` -////////////////////////////////////////////////////////////////////////////// -class Vec2f -////////////////////////////////////////////////////////////////////////////// +Vec2fᵖ is a pointer to a Vec2f element. -#### func (*Vec2f) Class +#### func NewVec2fᵖ ```go -func (*Vec2f) Class() binary.Class +func NewVec2fᵖ(addr memory.Pointer) Vec2fᵖ ``` +NewVec2fᵖ returns a Vec2fᵖ that points to addr in the application pool. -#### func (*Vec2f) GetCreatedAt +#### func (*Vec2fᵖ) Class ```go -func (c *Vec2f) GetCreatedAt() atom.ID +func (*Vec2fᵖ) Class() binary.Class ``` -#### func (*Vec2f) Init +#### func (Vec2fᵖ) ElementSize ```go -func (c *Vec2f) Init() +func (p Vec2fᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Vec2fᵖ points to. -#### func (Vec2f) String +#### func (Vec2fᵖ) Read ```go -func (v Vec2f) String() string +func (p Vec2fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec2f ``` +Read reads and returns the Vec2f element at the pointer. + +#### func (Vec2fᵖ) Slice + +```go +func (p Vec2fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec2fˢ +``` +Slice returns a new Vec2fˢ from the pointer using start and end indices. + +#### func (Vec2fᵖ) String + +```go +func (p Vec2fᵖ) String() string +``` +String returns a string description of the Vec2fᵖ pointer. + +#### func (Vec2fᵖ) Write + +```go +func (p Vec2fᵖ) Write(value Vec2f, ϟs *gfxapi.State) +``` +Write writes value to the Vec2f element at the pointer. #### type Vec2i ```go -type Vec2i struct { - binary.Generate - CreatedAt atom.ID - X int32 - Y int32 -} +type Vec2i S32ː2ᵃ ``` -////////////////////////////////////////////////////////////////////////////// -class Vec2i -////////////////////////////////////////////////////////////////////////////// #### func (*Vec2i) Class @@ -19546,56 +30551,203 @@ class Vec2i func (*Vec2i) Class() binary.Class ``` -#### func (*Vec2i) GetCreatedAt +#### func (Vec2i) String ```go -func (c *Vec2i) GetCreatedAt() atom.ID +func (v Vec2i) String() string ``` -#### func (*Vec2i) Init +#### type Vec2iˢ ```go -func (c *Vec2i) Init() +type Vec2iˢ struct { + binary.Generate + SliceInfo +} ``` -#### func (Vec2i) String +Vec2iˢ is a slice of Vec2i. + +#### func AsVec2iˢ ```go -func (v Vec2i) String() string +func AsVec2iˢ(s Slice, ϟs *gfxapi.State) Vec2iˢ ``` +AsVec2iˢ returns s cast to a Vec2iˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. -#### type Vec3f +#### func MakeVec2iˢ + +```go +func MakeVec2iˢ(count uint64, ϟs *gfxapi.State) Vec2iˢ +``` +MakeVec2iˢ returns a Vec2iˢ backed by a new memory pool. + +#### func (*Vec2iˢ) Class + +```go +func (*Vec2iˢ) Class() binary.Class +``` + +#### func (Vec2iˢ) Clone + +```go +func (s Vec2iˢ) Clone(ϟs *gfxapi.State) Vec2iˢ +``` +Clone returns a copy of the Vec2iˢ in a new memory pool. + +#### func (Vec2iˢ) Copy + +```go +func (dst Vec2iˢ) Copy(src Vec2iˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec2iˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Vec2iˢ) Decoder + +```go +func (s Vec2iˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Vec2iˢ) ElementSize + +```go +func (s Vec2iˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec2iˢ points to. + +#### func (Vec2iˢ) Encoder + +```go +func (s Vec2iˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec2iˢ) Index + +```go +func (s Vec2iˢ) Index(i uint64, ϟs *gfxapi.State) Vec2iᵖ +``` +Index returns a Vec2iᵖ to the i'th element in this Vec2iˢ. + +#### func (Vec2iˢ) Range + +```go +func (s Vec2iˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec2iˢ) Read + +```go +func (s Vec2iˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec2i +``` +Read reads and returns all the Vec2i elements in this Vec2iˢ. + +#### func (Vec2iˢ) ResourceID + +```go +func (s Vec2iˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Vec2iˢ) Slice ```go -type Vec3f struct { +func (s Vec2iˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec2iˢ +``` +Slice returns a sub-slice from the Vec2iˢ using start and end indices. + +#### func (Vec2iˢ) String + +```go +func (s Vec2iˢ) String() string +``` +String returns a string description of the Vec2iˢ slice. + +#### func (Vec2iˢ) Write + +```go +func (dst Vec2iˢ) Write(src []Vec2i, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec2iᵖ + +```go +type Vec2iᵖ struct { binary.Generate - CreatedAt atom.ID - X float32 - Y float32 - Z float32 + Address memory.Pointer + Pool memory.PoolID } ``` -////////////////////////////////////////////////////////////////////////////// -class Vec3f -////////////////////////////////////////////////////////////////////////////// +Vec2iᵖ is a pointer to a Vec2i element. -#### func (*Vec3f) Class +#### func NewVec2iᵖ ```go -func (*Vec3f) Class() binary.Class +func NewVec2iᵖ(addr memory.Pointer) Vec2iᵖ +``` +NewVec2iᵖ returns a Vec2iᵖ that points to addr in the application pool. + +#### func (*Vec2iᵖ) Class + +```go +func (*Vec2iᵖ) Class() binary.Class ``` -#### func (*Vec3f) GetCreatedAt +#### func (Vec2iᵖ) ElementSize ```go -func (c *Vec3f) GetCreatedAt() atom.ID +func (p Vec2iᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Vec2iᵖ points to. -#### func (*Vec3f) Init +#### func (Vec2iᵖ) Read ```go -func (c *Vec3f) Init() +func (p Vec2iᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec2i +``` +Read reads and returns the Vec2i element at the pointer. + +#### func (Vec2iᵖ) Slice + +```go +func (p Vec2iᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec2iˢ +``` +Slice returns a new Vec2iˢ from the pointer using start and end indices. + +#### func (Vec2iᵖ) String + +```go +func (p Vec2iᵖ) String() string +``` +String returns a string description of the Vec2iᵖ pointer. + +#### func (Vec2iᵖ) Write + +```go +func (p Vec2iᵖ) Write(value Vec2i, ϟs *gfxapi.State) +``` +Write writes value to the Vec2i element at the pointer. + +#### type Vec3f + +```go +type Vec3f F32ː3ᵃ +``` + + +#### func (*Vec3f) Class + +```go +func (*Vec3f) Class() binary.Class ``` #### func (Vec3f) String @@ -19604,38 +30756,213 @@ func (c *Vec3f) Init() func (v Vec3f) String() string ``` -#### type Vec3i +#### type Vec3fː3ᵃ ```go -type Vec3i struct { +type Vec3fː3ᵃ struct { binary.Generate - CreatedAt atom.ID - X int32 - Y int32 - Z int32 + Elements [3]Vec3f } ``` -////////////////////////////////////////////////////////////////////////////// -class Vec3i -////////////////////////////////////////////////////////////////////////////// -#### func (*Vec3i) Class +#### func (*Vec3fː3ᵃ) Class ```go -func (*Vec3i) Class() binary.Class +func (*Vec3fː3ᵃ) Class() binary.Class +``` + +#### type Vec3fˢ + +```go +type Vec3fˢ struct { + binary.Generate + SliceInfo +} +``` + +Vec3fˢ is a slice of Vec3f. + +#### func AsVec3fˢ + +```go +func AsVec3fˢ(s Slice, ϟs *gfxapi.State) Vec3fˢ +``` +AsVec3fˢ returns s cast to a Vec3fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeVec3fˢ + +```go +func MakeVec3fˢ(count uint64, ϟs *gfxapi.State) Vec3fˢ +``` +MakeVec3fˢ returns a Vec3fˢ backed by a new memory pool. + +#### func (*Vec3fˢ) Class + +```go +func (*Vec3fˢ) Class() binary.Class +``` + +#### func (Vec3fˢ) Clone + +```go +func (s Vec3fˢ) Clone(ϟs *gfxapi.State) Vec3fˢ ``` +Clone returns a copy of the Vec3fˢ in a new memory pool. + +#### func (Vec3fˢ) Copy + +```go +func (dst Vec3fˢ) Copy(src Vec3fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec3fˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Vec3fˢ) Decoder + +```go +func (s Vec3fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Vec3fˢ) ElementSize + +```go +func (s Vec3fˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec3fˢ points to. + +#### func (Vec3fˢ) Encoder + +```go +func (s Vec3fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec3fˢ) Index + +```go +func (s Vec3fˢ) Index(i uint64, ϟs *gfxapi.State) Vec3fᵖ +``` +Index returns a Vec3fᵖ to the i'th element in this Vec3fˢ. + +#### func (Vec3fˢ) Range + +```go +func (s Vec3fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec3fˢ) Read + +```go +func (s Vec3fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec3f +``` +Read reads and returns all the Vec3f elements in this Vec3fˢ. + +#### func (Vec3fˢ) ResourceID + +```go +func (s Vec3fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Vec3fˢ) Slice + +```go +func (s Vec3fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec3fˢ +``` +Slice returns a sub-slice from the Vec3fˢ using start and end indices. + +#### func (Vec3fˢ) String + +```go +func (s Vec3fˢ) String() string +``` +String returns a string description of the Vec3fˢ slice. + +#### func (Vec3fˢ) Write + +```go +func (dst Vec3fˢ) Write(src []Vec3f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec3fᵖ + +```go +type Vec3fᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Vec3fᵖ is a pointer to a Vec3f element. -#### func (*Vec3i) GetCreatedAt +#### func NewVec3fᵖ ```go -func (c *Vec3i) GetCreatedAt() atom.ID +func NewVec3fᵖ(addr memory.Pointer) Vec3fᵖ ``` +NewVec3fᵖ returns a Vec3fᵖ that points to addr in the application pool. -#### func (*Vec3i) Init +#### func (*Vec3fᵖ) Class ```go -func (c *Vec3i) Init() +func (*Vec3fᵖ) Class() binary.Class +``` + +#### func (Vec3fᵖ) ElementSize + +```go +func (p Vec3fᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec3fᵖ points to. + +#### func (Vec3fᵖ) Read + +```go +func (p Vec3fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec3f +``` +Read reads and returns the Vec3f element at the pointer. + +#### func (Vec3fᵖ) Slice + +```go +func (p Vec3fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec3fˢ +``` +Slice returns a new Vec3fˢ from the pointer using start and end indices. + +#### func (Vec3fᵖ) String + +```go +func (p Vec3fᵖ) String() string +``` +String returns a string description of the Vec3fᵖ pointer. + +#### func (Vec3fᵖ) Write + +```go +func (p Vec3fᵖ) Write(value Vec3f, ϟs *gfxapi.State) +``` +Write writes value to the Vec3f element at the pointer. + +#### type Vec3i + +```go +type Vec3i S32ː3ᵃ +``` + + +#### func (*Vec3i) Class + +```go +func (*Vec3i) Class() binary.Class ``` #### func (Vec3i) String @@ -19644,39 +30971,197 @@ func (c *Vec3i) Init() func (v Vec3i) String() string ``` -#### type Vec4f +#### type Vec3iˢ ```go -type Vec4f struct { +type Vec3iˢ struct { binary.Generate - CreatedAt atom.ID - X float32 - Y float32 - Z float32 - W float32 + SliceInfo } ``` -////////////////////////////////////////////////////////////////////////////// -class Vec4f -////////////////////////////////////////////////////////////////////////////// +Vec3iˢ is a slice of Vec3i. -#### func (*Vec4f) Class +#### func AsVec3iˢ ```go -func (*Vec4f) Class() binary.Class +func AsVec3iˢ(s Slice, ϟs *gfxapi.State) Vec3iˢ +``` +AsVec3iˢ returns s cast to a Vec3iˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeVec3iˢ + +```go +func MakeVec3iˢ(count uint64, ϟs *gfxapi.State) Vec3iˢ +``` +MakeVec3iˢ returns a Vec3iˢ backed by a new memory pool. + +#### func (*Vec3iˢ) Class + +```go +func (*Vec3iˢ) Class() binary.Class +``` + +#### func (Vec3iˢ) Clone + +```go +func (s Vec3iˢ) Clone(ϟs *gfxapi.State) Vec3iˢ +``` +Clone returns a copy of the Vec3iˢ in a new memory pool. + +#### func (Vec3iˢ) Copy + +```go +func (dst Vec3iˢ) Copy(src Vec3iˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec3iˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Vec3iˢ) Decoder + +```go +func (s Vec3iˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Vec3iˢ) ElementSize + +```go +func (s Vec3iˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec3iˢ points to. + +#### func (Vec3iˢ) Encoder + +```go +func (s Vec3iˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec3iˢ) Index + +```go +func (s Vec3iˢ) Index(i uint64, ϟs *gfxapi.State) Vec3iᵖ +``` +Index returns a Vec3iᵖ to the i'th element in this Vec3iˢ. + +#### func (Vec3iˢ) Range + +```go +func (s Vec3iˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec3iˢ) Read + +```go +func (s Vec3iˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec3i ``` +Read reads and returns all the Vec3i elements in this Vec3iˢ. -#### func (*Vec4f) GetCreatedAt +#### func (Vec3iˢ) ResourceID ```go -func (c *Vec4f) GetCreatedAt() atom.ID +func (s Vec3iˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### func (*Vec4f) Init +#### func (Vec3iˢ) Slice ```go -func (c *Vec4f) Init() +func (s Vec3iˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec3iˢ +``` +Slice returns a sub-slice from the Vec3iˢ using start and end indices. + +#### func (Vec3iˢ) String + +```go +func (s Vec3iˢ) String() string +``` +String returns a string description of the Vec3iˢ slice. + +#### func (Vec3iˢ) Write + +```go +func (dst Vec3iˢ) Write(src []Vec3i, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec3iᵖ + +```go +type Vec3iᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Vec3iᵖ is a pointer to a Vec3i element. + +#### func NewVec3iᵖ + +```go +func NewVec3iᵖ(addr memory.Pointer) Vec3iᵖ +``` +NewVec3iᵖ returns a Vec3iᵖ that points to addr in the application pool. + +#### func (*Vec3iᵖ) Class + +```go +func (*Vec3iᵖ) Class() binary.Class +``` + +#### func (Vec3iᵖ) ElementSize + +```go +func (p Vec3iᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec3iᵖ points to. + +#### func (Vec3iᵖ) Read + +```go +func (p Vec3iᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec3i +``` +Read reads and returns the Vec3i element at the pointer. + +#### func (Vec3iᵖ) Slice + +```go +func (p Vec3iᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec3iˢ +``` +Slice returns a new Vec3iˢ from the pointer using start and end indices. + +#### func (Vec3iᵖ) String + +```go +func (p Vec3iᵖ) String() string +``` +String returns a string description of the Vec3iᵖ pointer. + +#### func (Vec3iᵖ) Write + +```go +func (p Vec3iᵖ) Write(value Vec3i, ϟs *gfxapi.State) +``` +Write writes value to the Vec3i element at the pointer. + +#### type Vec4f + +```go +type Vec4f F32ː4ᵃ +``` + + +#### func (*Vec4f) Class + +```go +func (*Vec4f) Class() binary.Class ``` #### func (Vec4f) String @@ -19685,39 +31170,213 @@ func (c *Vec4f) Init() func (v Vec4f) String() string ``` -#### type Vec4i +#### type Vec4fː4ᵃ ```go -type Vec4i struct { +type Vec4fː4ᵃ struct { binary.Generate - CreatedAt atom.ID - X int32 - Y int32 - Z int32 - W int32 + Elements [4]Vec4f } ``` -////////////////////////////////////////////////////////////////////////////// -class Vec4i -////////////////////////////////////////////////////////////////////////////// -#### func (*Vec4i) Class +#### func (*Vec4fː4ᵃ) Class ```go -func (*Vec4i) Class() binary.Class +func (*Vec4fː4ᵃ) Class() binary.Class +``` + +#### type Vec4fˢ + +```go +type Vec4fˢ struct { + binary.Generate + SliceInfo +} +``` + +Vec4fˢ is a slice of Vec4f. + +#### func AsVec4fˢ + +```go +func AsVec4fˢ(s Slice, ϟs *gfxapi.State) Vec4fˢ +``` +AsVec4fˢ returns s cast to a Vec4fˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeVec4fˢ + +```go +func MakeVec4fˢ(count uint64, ϟs *gfxapi.State) Vec4fˢ +``` +MakeVec4fˢ returns a Vec4fˢ backed by a new memory pool. + +#### func (*Vec4fˢ) Class + +```go +func (*Vec4fˢ) Class() binary.Class +``` + +#### func (Vec4fˢ) Clone + +```go +func (s Vec4fˢ) Clone(ϟs *gfxapi.State) Vec4fˢ +``` +Clone returns a copy of the Vec4fˢ in a new memory pool. + +#### func (Vec4fˢ) Copy + +```go +func (dst Vec4fˢ) Copy(src Vec4fˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec4fˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Vec4fˢ) Decoder + +```go +func (s Vec4fˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Vec4fˢ) ElementSize + +```go +func (s Vec4fˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec4fˢ points to. + +#### func (Vec4fˢ) Encoder + +```go +func (s Vec4fˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec4fˢ) Index + +```go +func (s Vec4fˢ) Index(i uint64, ϟs *gfxapi.State) Vec4fᵖ +``` +Index returns a Vec4fᵖ to the i'th element in this Vec4fˢ. + +#### func (Vec4fˢ) Range + +```go +func (s Vec4fˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec4fˢ) Read + +```go +func (s Vec4fˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec4f +``` +Read reads and returns all the Vec4f elements in this Vec4fˢ. + +#### func (Vec4fˢ) ResourceID + +```go +func (s Vec4fˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Vec4fˢ) Slice + +```go +func (s Vec4fˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec4fˢ +``` +Slice returns a sub-slice from the Vec4fˢ using start and end indices. + +#### func (Vec4fˢ) String + +```go +func (s Vec4fˢ) String() string +``` +String returns a string description of the Vec4fˢ slice. + +#### func (Vec4fˢ) Write + +```go +func (dst Vec4fˢ) Write(src []Vec4f, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec4fᵖ + +```go +type Vec4fᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Vec4fᵖ is a pointer to a Vec4f element. + +#### func NewVec4fᵖ + +```go +func NewVec4fᵖ(addr memory.Pointer) Vec4fᵖ ``` +NewVec4fᵖ returns a Vec4fᵖ that points to addr in the application pool. -#### func (*Vec4i) GetCreatedAt +#### func (*Vec4fᵖ) Class ```go -func (c *Vec4i) GetCreatedAt() atom.ID +func (*Vec4fᵖ) Class() binary.Class ``` -#### func (*Vec4i) Init +#### func (Vec4fᵖ) ElementSize ```go -func (c *Vec4i) Init() +func (p Vec4fᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec4fᵖ points to. + +#### func (Vec4fᵖ) Read + +```go +func (p Vec4fᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec4f +``` +Read reads and returns the Vec4f element at the pointer. + +#### func (Vec4fᵖ) Slice + +```go +func (p Vec4fᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec4fˢ +``` +Slice returns a new Vec4fˢ from the pointer using start and end indices. + +#### func (Vec4fᵖ) String + +```go +func (p Vec4fᵖ) String() string +``` +String returns a string description of the Vec4fᵖ pointer. + +#### func (Vec4fᵖ) Write + +```go +func (p Vec4fᵖ) Write(value Vec4f, ϟs *gfxapi.State) +``` +Write writes value to the Vec4f element at the pointer. + +#### type Vec4i + +```go +type Vec4i S32ː4ᵃ +``` + + +#### func (*Vec4i) Class + +```go +func (*Vec4i) Class() binary.Class ``` #### func (Vec4i) String @@ -19726,6 +31385,207 @@ func (c *Vec4i) Init() func (v Vec4i) String() string ``` +#### type Vec4iˢ + +```go +type Vec4iˢ struct { + binary.Generate + SliceInfo +} +``` + +Vec4iˢ is a slice of Vec4i. + +#### func AsVec4iˢ + +```go +func AsVec4iˢ(s Slice, ϟs *gfxapi.State) Vec4iˢ +``` +AsVec4iˢ returns s cast to a Vec4iˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeVec4iˢ + +```go +func MakeVec4iˢ(count uint64, ϟs *gfxapi.State) Vec4iˢ +``` +MakeVec4iˢ returns a Vec4iˢ backed by a new memory pool. + +#### func (*Vec4iˢ) Class + +```go +func (*Vec4iˢ) Class() binary.Class +``` + +#### func (Vec4iˢ) Clone + +```go +func (s Vec4iˢ) Clone(ϟs *gfxapi.State) Vec4iˢ +``` +Clone returns a copy of the Vec4iˢ in a new memory pool. + +#### func (Vec4iˢ) Copy + +```go +func (dst Vec4iˢ) Copy(src Vec4iˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Vec4iˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Vec4iˢ) Decoder + +```go +func (s Vec4iˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Vec4iˢ) ElementSize + +```go +func (s Vec4iˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec4iˢ points to. + +#### func (Vec4iˢ) Encoder + +```go +func (s Vec4iˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Vec4iˢ) Index + +```go +func (s Vec4iˢ) Index(i uint64, ϟs *gfxapi.State) Vec4iᵖ +``` +Index returns a Vec4iᵖ to the i'th element in this Vec4iˢ. + +#### func (Vec4iˢ) Range + +```go +func (s Vec4iˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Vec4iˢ) Read + +```go +func (s Vec4iˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Vec4i +``` +Read reads and returns all the Vec4i elements in this Vec4iˢ. + +#### func (Vec4iˢ) ResourceID + +```go +func (s Vec4iˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Vec4iˢ) Slice + +```go +func (s Vec4iˢ) Slice(start, end uint64, ϟs *gfxapi.State) Vec4iˢ +``` +Slice returns a sub-slice from the Vec4iˢ using start and end indices. + +#### func (Vec4iˢ) String + +```go +func (s Vec4iˢ) String() string +``` +String returns a string description of the Vec4iˢ slice. + +#### func (Vec4iˢ) Write + +```go +func (dst Vec4iˢ) Write(src []Vec4i, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Vec4iᵖ + +```go +type Vec4iᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Vec4iᵖ is a pointer to a Vec4i element. + +#### func NewVec4iᵖ + +```go +func NewVec4iᵖ(addr memory.Pointer) Vec4iᵖ +``` +NewVec4iᵖ returns a Vec4iᵖ that points to addr in the application pool. + +#### func (*Vec4iᵖ) Class + +```go +func (*Vec4iᵖ) Class() binary.Class +``` + +#### func (Vec4iᵖ) ElementSize + +```go +func (p Vec4iᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Vec4iᵖ points to. + +#### func (Vec4iᵖ) Read + +```go +func (p Vec4iᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Vec4i +``` +Read reads and returns the Vec4i element at the pointer. + +#### func (Vec4iᵖ) Slice + +```go +func (p Vec4iᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Vec4iˢ +``` +Slice returns a new Vec4iˢ from the pointer using start and end indices. + +#### func (Vec4iᵖ) String + +```go +func (p Vec4iᵖ) String() string +``` +String returns a string description of the Vec4iᵖ pointer. + +#### func (Vec4iᵖ) Write + +```go +func (p Vec4iᵖ) Write(value Vec4i, ϟs *gfxapi.State) +``` +Write writes value to the Vec4i element at the pointer. + +#### type Version + +```go +type Version struct { + IsES bool + Major int + Minor int +} +``` + +Version represents the GL version major and minor numbers, and whether its +flavour is ES, as opposed to Desktop GL. + +#### func ParseVersion + +```go +func ParseVersion(str string) (*Version, error) +``` +ParseVersion parses the GL version major, minor and flavour from the output of +glGetString(GL_VERSION). + #### type VertexArray ```go @@ -19757,93 +31617,226 @@ func (c *VertexArray) GetCreatedAt() atom.ID func (c *VertexArray) Init() ``` -#### type VertexArrayArray +#### type VertexArrayId ```go -type VertexArrayArray []VertexArray +type VertexArrayId uint32 ``` -#### func (VertexArrayArray) Len +#### type VertexArrayIdːVertexArrayʳᵐ ```go -func (s VertexArrayArray) Len() int +type VertexArrayIdːVertexArrayʳᵐ map[VertexArrayId](*VertexArray) ``` -#### func (VertexArrayArray) Range + +#### func (VertexArrayIdːVertexArrayʳᵐ) Contains ```go -func (s VertexArrayArray) Range() []VertexArray +func (m VertexArrayIdːVertexArrayʳᵐ) Contains(key VertexArrayId) bool ``` -#### type VertexArrayId +#### func (VertexArrayIdːVertexArrayʳᵐ) Delete ```go -type VertexArrayId uint32 +func (m VertexArrayIdːVertexArrayʳᵐ) Delete(key VertexArrayId) ``` +#### func (VertexArrayIdːVertexArrayʳᵐ) Get -#### func (*VertexArrayId) Equal +```go +func (m VertexArrayIdːVertexArrayʳᵐ) Get(key VertexArrayId) *VertexArray +``` + +#### func (VertexArrayIdːVertexArrayʳᵐ) Range ```go -func (c *VertexArrayId) Equal(rhs VertexArrayId) bool +func (m VertexArrayIdːVertexArrayʳᵐ) Range() [](*VertexArray) ``` -#### func (*VertexArrayId) Less +#### type VertexArrayIdˢ ```go -func (c *VertexArrayId) Less(rhs VertexArrayId) bool +type VertexArrayIdˢ struct { + binary.Generate + SliceInfo +} ``` -#### type VertexArrayIdArray +VertexArrayIdˢ is a slice of VertexArrayId. + +#### func AsVertexArrayIdˢ ```go -type VertexArrayIdArray []VertexArrayId +func AsVertexArrayIdˢ(s Slice, ϟs *gfxapi.State) VertexArrayIdˢ ``` +AsVertexArrayIdˢ returns s cast to a VertexArrayIdˢ. The returned slice length +will be calculated so that the returned slice is no longer (in bytes) than s. +#### func MakeVertexArrayIdˢ -#### func (VertexArrayIdArray) Len +```go +func MakeVertexArrayIdˢ(count uint64, ϟs *gfxapi.State) VertexArrayIdˢ +``` +MakeVertexArrayIdˢ returns a VertexArrayIdˢ backed by a new memory pool. + +#### func (*VertexArrayIdˢ) Class + +```go +func (*VertexArrayIdˢ) Class() binary.Class +``` + +#### func (VertexArrayIdˢ) Clone ```go -func (s VertexArrayIdArray) Len() int +func (s VertexArrayIdˢ) Clone(ϟs *gfxapi.State) VertexArrayIdˢ ``` +Clone returns a copy of the VertexArrayIdˢ in a new memory pool. -#### func (VertexArrayIdArray) Range +#### func (VertexArrayIdˢ) Copy ```go -func (s VertexArrayIdArray) Range() []VertexArrayId +func (dst VertexArrayIdˢ) Copy(src VertexArrayIdˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s VertexArrayIdˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### type VertexArrayPtr_VertexArrayIdMap +#### func (VertexArrayIdˢ) Decoder ```go -type VertexArrayPtr_VertexArrayIdMap map[VertexArrayId]*VertexArray +func (s VertexArrayIdˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. + +#### func (VertexArrayIdˢ) ElementSize +```go +func (s VertexArrayIdˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that VertexArrayIdˢ points +to. -#### func (VertexArrayPtr_VertexArrayIdMap) Contains +#### func (VertexArrayIdˢ) Encoder ```go -func (m VertexArrayPtr_VertexArrayIdMap) Contains(key VertexArrayId) bool +func (s VertexArrayIdˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (VertexArrayPtr_VertexArrayIdMap) Delete +#### func (VertexArrayIdˢ) Index ```go -func (m VertexArrayPtr_VertexArrayIdMap) Delete(key VertexArrayId) +func (s VertexArrayIdˢ) Index(i uint64, ϟs *gfxapi.State) VertexArrayIdᵖ ``` +Index returns a VertexArrayIdᵖ to the i'th element in this VertexArrayIdˢ. -#### func (VertexArrayPtr_VertexArrayIdMap) Get +#### func (VertexArrayIdˢ) Range ```go -func (m VertexArrayPtr_VertexArrayIdMap) Get(key VertexArrayId) *VertexArray +func (s VertexArrayIdˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### func (VertexArrayPtr_VertexArrayIdMap) Range +#### func (VertexArrayIdˢ) Read ```go -func (m VertexArrayPtr_VertexArrayIdMap) Range() []*VertexArray +func (s VertexArrayIdˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []VertexArrayId ``` +Read reads and returns all the VertexArrayId elements in this VertexArrayIdˢ. + +#### func (VertexArrayIdˢ) ResourceID + +```go +func (s VertexArrayIdˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (VertexArrayIdˢ) Slice + +```go +func (s VertexArrayIdˢ) Slice(start, end uint64, ϟs *gfxapi.State) VertexArrayIdˢ +``` +Slice returns a sub-slice from the VertexArrayIdˢ using start and end indices. + +#### func (VertexArrayIdˢ) String + +```go +func (s VertexArrayIdˢ) String() string +``` +String returns a string description of the VertexArrayIdˢ slice. + +#### func (VertexArrayIdˢ) Write + +```go +func (dst VertexArrayIdˢ) Write(src []VertexArrayId, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type VertexArrayIdᵖ + +```go +type VertexArrayIdᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +VertexArrayIdᵖ is a pointer to a VertexArrayId element. + +#### func NewVertexArrayIdᵖ + +```go +func NewVertexArrayIdᵖ(addr memory.Pointer) VertexArrayIdᵖ +``` +NewVertexArrayIdᵖ returns a VertexArrayIdᵖ that points to addr in the +application pool. + +#### func (*VertexArrayIdᵖ) Class + +```go +func (*VertexArrayIdᵖ) Class() binary.Class +``` + +#### func (VertexArrayIdᵖ) ElementSize + +```go +func (p VertexArrayIdᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that VertexArrayIdᵖ points +to. + +#### func (VertexArrayIdᵖ) Read + +```go +func (p VertexArrayIdᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) VertexArrayId +``` +Read reads and returns the VertexArrayId element at the pointer. + +#### func (VertexArrayIdᵖ) Slice + +```go +func (p VertexArrayIdᵖ) Slice(start, end uint64, ϟs *gfxapi.State) VertexArrayIdˢ +``` +Slice returns a new VertexArrayIdˢ from the pointer using start and end indices. + +#### func (VertexArrayIdᵖ) String + +```go +func (p VertexArrayIdᵖ) String() string +``` +String returns a string description of the VertexArrayIdᵖ pointer. + +#### func (VertexArrayIdᵖ) Write + +```go +func (p VertexArrayIdᵖ) Write(value VertexArrayId, ϟs *gfxapi.State) +``` +Write writes value to the VertexArrayId element at the pointer. #### type VertexAttribType @@ -19855,6 +31848,12 @@ type VertexAttribType uint32 enum VertexAttribType ////////////////////////////////////////////////////////////////////////////// +#### func (*VertexAttribType) Parse + +```go +func (v *VertexAttribType) Parse(s string) error +``` + #### func (VertexAttribType) String ```go @@ -19867,7 +31866,7 @@ func (v VertexAttribType) String() string type VertexAttribute struct { binary.Generate CreatedAt atom.ID - Name string + Name Charˢ VectorCount int32 Type ShaderAttribType } @@ -19907,7 +31906,7 @@ type VertexAttributeArray struct { Normalized bool Stride int32 Buffer BufferId - Pointer memory.Pointer + Pointer VertexPointer } ``` @@ -19939,111 +31938,194 @@ func (c *VertexAttributeArray) Init() func (a VertexAttributeArray) String() string ``` -#### type VertexAttributeArrayArray +#### type VertexPointer ```go -type VertexAttributeArrayArray []VertexAttributeArray +type VertexPointer struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` +VertexPointer is a pointer to a void element. -#### func (VertexAttributeArrayArray) Len +#### func NewVertexPointer ```go -func (s VertexAttributeArrayArray) Len() int +func NewVertexPointer(addr memory.Pointer) VertexPointer ``` +NewVertexPointer returns a VertexPointer that points to addr in the application +pool. -#### func (VertexAttributeArrayArray) Range +#### func (*VertexPointer) Class ```go -func (s VertexAttributeArrayArray) Range() []VertexAttributeArray +func (*VertexPointer) Class() binary.Class ``` -#### type VertexAttributeArrayPtr_AttributeLocationMap +#### func (VertexPointer) ElementSize ```go -type VertexAttributeArrayPtr_AttributeLocationMap map[AttributeLocation]*VertexAttributeArray +func (p VertexPointer) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that VertexPointer points +to. + +#### func (VertexPointer) Slice +```go +func (p VertexPointer) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (VertexAttributeArrayPtr_AttributeLocationMap) Contains +#### func (VertexPointer) String ```go -func (m VertexAttributeArrayPtr_AttributeLocationMap) Contains(key AttributeLocation) bool +func (p VertexPointer) String() string ``` +String returns a string description of the VertexPointer pointer. -#### func (VertexAttributeArrayPtr_AttributeLocationMap) Delete +#### type Voidˢ ```go -func (m VertexAttributeArrayPtr_AttributeLocationMap) Delete(key AttributeLocation) +type Voidˢ struct { + binary.Generate + SliceInfo +} ``` -#### func (VertexAttributeArrayPtr_AttributeLocationMap) Get +Voidˢ is a slice of void. + +#### func MakeVoidˢ ```go -func (m VertexAttributeArrayPtr_AttributeLocationMap) Get(key AttributeLocation) *VertexAttributeArray +func MakeVoidˢ(count uint64, ϟs *gfxapi.State) Voidˢ ``` +MakeVoidˢ returns a Voidˢ backed by a new memory pool. -#### func (VertexAttributeArrayPtr_AttributeLocationMap) Range +#### func (*Voidˢ) Class ```go -func (m VertexAttributeArrayPtr_AttributeLocationMap) Range() []*VertexAttributeArray +func (*Voidˢ) Class() binary.Class ``` -#### type VertexAttribute_s32Map +#### func (Voidˢ) Clone ```go -type VertexAttribute_s32Map map[int32]VertexAttribute +func (s Voidˢ) Clone(ϟs *gfxapi.State) Voidˢ ``` +Clone returns a copy of the Voidˢ in a new memory pool. + +#### func (Voidˢ) Decoder +```go +func (s Voidˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. -#### func (VertexAttribute_s32Map) Contains +#### func (Voidˢ) ElementSize ```go -func (m VertexAttribute_s32Map) Contains(key int32) bool +func (s Voidˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Voidˢ points to. -#### func (VertexAttribute_s32Map) Delete +#### func (Voidˢ) Encoder ```go -func (m VertexAttribute_s32Map) Delete(key int32) +func (s Voidˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (VertexAttribute_s32Map) Get +#### func (Voidˢ) Index ```go -func (m VertexAttribute_s32Map) Get(key int32) VertexAttribute +func (s Voidˢ) Index(i uint64, ϟs *gfxapi.State) Voidᵖ ``` +Index returns a Voidᵖ to the i'th element in this Voidˢ. -#### func (VertexAttribute_s32Map) Range +#### func (Voidˢ) Range ```go -func (m VertexAttribute_s32Map) Range() []VertexAttribute +func (s Voidˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### type VertexPointer +#### func (Voidˢ) ResourceID ```go -type VertexPointer memory.Pointer +func (s Voidˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. +#### func (Voidˢ) Slice -#### func (*VertexPointer) Equal +```go +func (s Voidˢ) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a sub-slice from the Voidˢ using start and end indices. + +#### func (Voidˢ) String + +```go +func (s Voidˢ) String() string +``` +String returns a string description of the Voidˢ slice. + +#### type Voidᵖ + +```go +type Voidᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Voidᵖ is a pointer to a void element. + +#### func NewVoidᵖ + +```go +func NewVoidᵖ(addr memory.Pointer) Voidᵖ +``` +NewVoidᵖ returns a Voidᵖ that points to addr in the application pool. + +#### func (*Voidᵖ) Class ```go -func (c *VertexPointer) Equal(rhs VertexPointer) bool +func (*Voidᵖ) Class() binary.Class ``` -#### func (*VertexPointer) Less +#### func (Voidᵖ) ElementSize ```go -func (c *VertexPointer) Less(rhs VertexPointer) bool +func (p Voidᵖ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Voidᵖ points to. + +#### func (Voidᵖ) Slice + +```go +func (p Voidᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a new Voidˢ from the pointer using start and end indices. + +#### func (Voidᵖ) String + +```go +func (p Voidᵖ) String() string +``` +String returns a string description of the Voidᵖ pointer. #### type WglCreateContext ```go type WglCreateContext struct { binary.Generate + Hdc HDC Result HGLRC } @@ -20056,10 +32138,7 @@ WglCreateContext #### func NewWglCreateContext ```go -func NewWglCreateContext( - pHdc HDC, - pResult HGLRC, -) *WglCreateContext +func NewWglCreateContext(Hdc memory.Pointer, Result memory.Pointer) *WglCreateContext ``` #### func (*WglCreateContext) API @@ -20068,6 +32147,22 @@ func NewWglCreateContext( func (c *WglCreateContext) API() gfxapi.API ``` +#### func (*WglCreateContext) AddRead + +```go +func (a *WglCreateContext) AddRead(rng memory.Range, id binary.ID) *WglCreateContext +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The WglCreateContext pointer is returned so that calls can be chained. + +#### func (*WglCreateContext) AddWrite + +```go +func (a *WglCreateContext) AddWrite(rng memory.Range, id binary.ID) *WglCreateContext +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The WglCreateContext pointer is returned so that calls can be chained. + #### func (*WglCreateContext) Class ```go @@ -20083,19 +32178,25 @@ func (c *WglCreateContext) Flags() atom.Flags #### func (*WglCreateContext) Mutate ```go -func (ϟa *WglCreateContext) Mutate(ϟs *gfxapi.State) error +func (ϟa *WglCreateContext) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*WglCreateContext) Observations + +```go +func (a *WglCreateContext) Observations() *atom.Observations ``` #### func (*WglCreateContext) Replay ```go -func (ω *WglCreateContext) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (ω *WglCreateContext) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` #### func (*WglCreateContext) String ```go -func (c *WglCreateContext) String() string +func (a *WglCreateContext) String() string ``` #### func (*WglCreateContext) TypeID @@ -20109,9 +32210,10 @@ func (c *WglCreateContext) TypeID() atom.TypeID ```go type WglCreateContextAttribsARB struct { binary.Generate + Hdc HDC HShareContext HGLRC - AttribList IntArray + AttribList Intᵖ Result HGLRC } ``` @@ -20123,12 +32225,7 @@ WglCreateContextAttribsARB #### func NewWglCreateContextAttribsARB ```go -func NewWglCreateContextAttribsARB( - pHdc HDC, - pHShareContext HGLRC, - pAttribList IntArray, - pResult HGLRC, -) *WglCreateContextAttribsARB +func NewWglCreateContextAttribsARB(Hdc memory.Pointer, HShareContext memory.Pointer, AttribList memory.Pointer, Result memory.Pointer) *WglCreateContextAttribsARB ``` #### func (*WglCreateContextAttribsARB) API @@ -20137,70 +32234,64 @@ func NewWglCreateContextAttribsARB( func (c *WglCreateContextAttribsARB) API() gfxapi.API ``` -#### func (*WglCreateContextAttribsARB) Class +#### func (*WglCreateContextAttribsARB) AddRead ```go -func (*WglCreateContextAttribsARB) Class() binary.Class +func (a *WglCreateContextAttribsARB) AddRead(rng memory.Range, id binary.ID) *WglCreateContextAttribsARB ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The WglCreateContextAttribsARB pointer is returned so that calls can be +chained. -#### func (*WglCreateContextAttribsARB) Flags +#### func (*WglCreateContextAttribsARB) AddWrite ```go -func (c *WglCreateContextAttribsARB) Flags() atom.Flags +func (a *WglCreateContextAttribsARB) AddWrite(rng memory.Range, id binary.ID) *WglCreateContextAttribsARB ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The WglCreateContextAttribsARB pointer is returned so that calls can be +chained. -#### func (*WglCreateContextAttribsARB) Mutate - -```go -func (ϟa *WglCreateContextAttribsARB) Mutate(ϟs *gfxapi.State) error -``` - -#### func (*WglCreateContextAttribsARB) Replay +#### func (*WglCreateContextAttribsARB) Class ```go -func (ω *WglCreateContextAttribsARB) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (*WglCreateContextAttribsARB) Class() binary.Class ``` -#### func (*WglCreateContextAttribsARB) String +#### func (*WglCreateContextAttribsARB) Flags ```go -func (c *WglCreateContextAttribsARB) String() string +func (c *WglCreateContextAttribsARB) Flags() atom.Flags ``` -#### func (*WglCreateContextAttribsARB) TypeID +#### func (*WglCreateContextAttribsARB) Mutate ```go -func (c *WglCreateContextAttribsARB) TypeID() atom.TypeID +func (ϟa *WglCreateContextAttribsARB) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### type WglCreateContextAttribsARB_Postback +#### func (*WglCreateContextAttribsARB) Observations ```go -type WglCreateContextAttribsARB_Postback struct { - Result []byte -} +func (a *WglCreateContextAttribsARB) Observations() *atom.Observations ``` - -#### func (*WglCreateContextAttribsARB_Postback) Decode +#### func (*WglCreateContextAttribsARB) Replay ```go -func (o *WglCreateContextAttribsARB_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (ω *WglCreateContextAttribsARB) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` -#### type WglCreateContext_Postback +#### func (*WglCreateContextAttribsARB) String ```go -type WglCreateContext_Postback struct { - Result []byte -} +func (a *WglCreateContextAttribsARB) String() string ``` - -#### func (*WglCreateContext_Postback) Decode +#### func (*WglCreateContextAttribsARB) TypeID ```go -func (o *WglCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *WglCreateContextAttribsARB) TypeID() atom.TypeID ``` #### type WglMakeCurrent @@ -20208,6 +32299,7 @@ func (o *WglCreateContext_Postback) Decode(result_cnt uint64, d binary.Decoder) ```go type WglMakeCurrent struct { binary.Generate + Hdc HDC Hglrc HGLRC Result BOOL @@ -20221,11 +32313,7 @@ WglMakeCurrent #### func NewWglMakeCurrent ```go -func NewWglMakeCurrent( - pHdc HDC, - pHglrc HGLRC, - pResult BOOL, -) *WglMakeCurrent +func NewWglMakeCurrent(Hdc memory.Pointer, Hglrc memory.Pointer, Result BOOL) *WglMakeCurrent ``` #### func (*WglMakeCurrent) API @@ -20234,55 +32322,62 @@ func NewWglMakeCurrent( func (c *WglMakeCurrent) API() gfxapi.API ``` -#### func (*WglMakeCurrent) Class +#### func (*WglMakeCurrent) AddRead ```go -func (*WglMakeCurrent) Class() binary.Class +func (a *WglMakeCurrent) AddRead(rng memory.Range, id binary.ID) *WglMakeCurrent ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The WglMakeCurrent pointer is returned so that calls can be chained. -#### func (*WglMakeCurrent) Flags +#### func (*WglMakeCurrent) AddWrite ```go -func (c *WglMakeCurrent) Flags() atom.Flags +func (a *WglMakeCurrent) AddWrite(rng memory.Range, id binary.ID) *WglMakeCurrent ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The WglMakeCurrent pointer is returned so that calls can be chained. -#### func (*WglMakeCurrent) Mutate +#### func (*WglMakeCurrent) Class ```go -func (ϟa *WglMakeCurrent) Mutate(ϟs *gfxapi.State) error +func (*WglMakeCurrent) Class() binary.Class ``` -#### func (*WglMakeCurrent) Replay +#### func (*WglMakeCurrent) Flags ```go -func (ω *WglMakeCurrent) Replay(id atom.ID, gs *gfxapi.State, b *builder.Builder, wantOutput bool) +func (c *WglMakeCurrent) Flags() atom.Flags ``` -#### func (*WglMakeCurrent) String +#### func (*WglMakeCurrent) Mutate ```go -func (c *WglMakeCurrent) String() string +func (ϟa *WglMakeCurrent) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*WglMakeCurrent) TypeID +#### func (*WglMakeCurrent) Observations ```go -func (c *WglMakeCurrent) TypeID() atom.TypeID +func (a *WglMakeCurrent) Observations() *atom.Observations ``` -#### type WglMakeCurrent_Postback +#### func (*WglMakeCurrent) Replay ```go -type WglMakeCurrent_Postback struct { - Result BOOL -} +func (ω *WglMakeCurrent) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error ``` +#### func (*WglMakeCurrent) String + +```go +func (a *WglMakeCurrent) String() string +``` -#### func (*WglMakeCurrent_Postback) Decode +#### func (*WglMakeCurrent) TypeID ```go -func (o *WglMakeCurrent_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *WglMakeCurrent) TypeID() atom.TypeID ``` #### type WglSwapBuffers @@ -20290,6 +32385,7 @@ func (o *WglMakeCurrent_Postback) Decode(result_cnt uint64, d binary.Decoder) er ```go type WglSwapBuffers struct { binary.Generate + Hdc HDC } ``` @@ -20301,9 +32397,7 @@ WglSwapBuffers #### func NewWglSwapBuffers ```go -func NewWglSwapBuffers( - pHdc HDC, -) *WglSwapBuffers +func NewWglSwapBuffers(Hdc memory.Pointer) *WglSwapBuffers ``` #### func (*WglSwapBuffers) API @@ -20312,6 +32406,22 @@ func NewWglSwapBuffers( func (c *WglSwapBuffers) API() gfxapi.API ``` +#### func (*WglSwapBuffers) AddRead + +```go +func (a *WglSwapBuffers) AddRead(rng memory.Range, id binary.ID) *WglSwapBuffers +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The WglSwapBuffers pointer is returned so that calls can be chained. + +#### func (*WglSwapBuffers) AddWrite + +```go +func (a *WglSwapBuffers) AddWrite(rng memory.Range, id binary.ID) *WglSwapBuffers +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The WglSwapBuffers pointer is returned so that calls can be chained. + #### func (*WglSwapBuffers) Class ```go @@ -20327,13 +32437,19 @@ func (c *WglSwapBuffers) Flags() atom.Flags #### func (*WglSwapBuffers) Mutate ```go -func (ϟa *WglSwapBuffers) Mutate(ϟs *gfxapi.State) error +func (ϟa *WglSwapBuffers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*WglSwapBuffers) Observations + +```go +func (a *WglSwapBuffers) Observations() *atom.Observations ``` #### func (*WglSwapBuffers) String ```go -func (c *WglSwapBuffers) String() string +func (a *WglSwapBuffers) String() string ``` #### func (*WglSwapBuffers) TypeID diff --git a/gfxapi/schema/README.md b/gfxapi/schema/README.md index b0fadc4a7..39b76f2b1 100644 --- a/gfxapi/schema/README.md +++ b/gfxapi/schema/README.md @@ -26,7 +26,7 @@ var ID = service.CreateSimpleInfo("id", service.TypeKindID) ``` ```go -var Int = service.CreateSimpleInfo("int", service.TypeKindS8) +var Int = service.CreateSimpleInfo("int", service.TypeKindS64) ``` ```go @@ -74,7 +74,7 @@ var U8 = service.CreateSimpleInfo("u8", service.TypeKindU8) ``` ```go -var Uint = service.CreateSimpleInfo("uint", service.TypeKindU8) +var Uint = service.CreateSimpleInfo("uint", service.TypeKindU64) ``` #### func RegisterAPI diff --git a/gfxapi/test/README.md b/gfxapi/test/README.md index 45a03bbe9..ef82b8bb7 100644 --- a/gfxapi/test/README.md +++ b/gfxapi/test/README.md @@ -12,108 +12,574 @@ Package test is the integration test suite for the api compiler and templates. func API() gfxapi.API ``` -#### type BoolArray +#### type Boolˢ ```go -type BoolArray []bool +type Boolˢ struct { + binary.Generate + SliceInfo +} +``` + +Boolˢ is a slice of bool. + +#### func AsBoolˢ + +```go +func AsBoolˢ(s Slice, ϟs *gfxapi.State) Boolˢ ``` +AsBoolˢ returns s cast to a Boolˢ. The returned slice length will be calculated +so that the returned slice is no longer (in bytes) than s. +#### func MakeBoolˢ + +```go +func MakeBoolˢ(count uint64, ϟs *gfxapi.State) Boolˢ +``` +MakeBoolˢ returns a Boolˢ backed by a new memory pool. + +#### func (*Boolˢ) Class + +```go +func (*Boolˢ) Class() binary.Class +``` -#### func (BoolArray) Len +#### func (Boolˢ) Clone ```go -func (s BoolArray) Len() int +func (s Boolˢ) Clone(ϟs *gfxapi.State) Boolˢ ``` +Clone returns a copy of the Boolˢ in a new memory pool. -#### func (BoolArray) Range +#### func (Boolˢ) Copy ```go -func (s BoolArray) Range() []bool +func (dst Boolˢ) Copy(src Boolˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Boolˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### type CmdArrayOfFloat +#### func (Boolˢ) Decoder ```go -type CmdArrayOfFloat struct { +func (s Boolˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Boolˢ) ElementSize + +```go +func (s Boolˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Boolˢ points to. + +#### func (Boolˢ) Encoder + +```go +func (s Boolˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Boolˢ) Index + +```go +func (s Boolˢ) Index(i uint64, ϟs *gfxapi.State) Boolᵖ +``` +Index returns a Boolᵖ to the i'th element in this Boolˢ. + +#### func (Boolˢ) Range + +```go +func (s Boolˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Boolˢ) Read + +```go +func (s Boolˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []bool +``` +Read reads and returns all the bool elements in this Boolˢ. + +#### func (Boolˢ) ResourceID + +```go +func (s Boolˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Boolˢ) Slice + +```go +func (s Boolˢ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ +``` +Slice returns a sub-slice from the Boolˢ using start and end indices. + +#### func (Boolˢ) String + +```go +func (s Boolˢ) String() string +``` +String returns a string description of the Boolˢ slice. + +#### func (Boolˢ) Write + +```go +func (dst Boolˢ) Write(src []bool, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Boolᵖ + +```go +type Boolᵖ struct { binary.Generate - Result F32Array + Address memory.Pointer + Pool memory.PoolID } ``` -////////////////////////////////////////////////////////////////////////////// -CmdArrayOfFloat -////////////////////////////////////////////////////////////////////////////// +Boolᵖ is a pointer to a bool element. + +#### func NewBoolᵖ + +```go +func NewBoolᵖ(addr memory.Pointer) Boolᵖ +``` +NewBoolᵖ returns a Boolᵖ that points to addr in the application pool. + +#### func (*Boolᵖ) Class + +```go +func (*Boolᵖ) Class() binary.Class +``` + +#### func (Boolᵖ) ElementSize + +```go +func (p Boolᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Boolᵖ points to. + +#### func (Boolᵖ) Read + +```go +func (p Boolᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) bool +``` +Read reads and returns the bool element at the pointer. + +#### func (Boolᵖ) Slice + +```go +func (p Boolᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ +``` +Slice returns a new Boolˢ from the pointer using start and end indices. + +#### func (Boolᵖ) String + +```go +func (p Boolᵖ) String() string +``` +String returns a string description of the Boolᵖ pointer. + +#### func (Boolᵖ) Write + +```go +func (p Boolᵖ) Write(value bool, ϟs *gfxapi.State) +``` +Write writes value to the bool element at the pointer. + +#### type Charˢ + +```go +type Charˢ struct { + binary.Generate + SliceInfo +} +``` + +Charˢ is a slice of byte. + +#### func AsCharˢ + +```go +func AsCharˢ(s Slice, ϟs *gfxapi.State) Charˢ +``` +AsCharˢ returns s cast to a Charˢ. The returned slice length will be calculated +so that the returned slice is no longer (in bytes) than s. + +#### func MakeCharˢ + +```go +func MakeCharˢ(count uint64, ϟs *gfxapi.State) Charˢ +``` +MakeCharˢ returns a Charˢ backed by a new memory pool. + +#### func MakeCharˢFromString + +```go +func MakeCharˢFromString(str string, ϟs *gfxapi.State) Charˢ +``` +MakeCharˢFromString returns a Charˢ backed by a new memory pool containing a +copy of str. + +#### func (*Charˢ) Class + +```go +func (*Charˢ) Class() binary.Class +``` + +#### func (Charˢ) Clone + +```go +func (s Charˢ) Clone(ϟs *gfxapi.State) Charˢ +``` +Clone returns a copy of the Charˢ in a new memory pool. + +#### func (Charˢ) Copy + +```go +func (dst Charˢ) Copy(src Charˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Charˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Charˢ) Decoder + +```go +func (s Charˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Charˢ) ElementSize + +```go +func (s Charˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charˢ points to. + +#### func (Charˢ) Encoder + +```go +func (s Charˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Charˢ) Index + +```go +func (s Charˢ) Index(i uint64, ϟs *gfxapi.State) Charᵖ +``` +Index returns a Charᵖ to the i'th element in this Charˢ. + +#### func (Charˢ) Range + +```go +func (s Charˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Charˢ) Read + +```go +func (s Charˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []byte +``` +Read reads and returns all the byte elements in this Charˢ. + +#### func (Charˢ) ResourceID + +```go +func (s Charˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Charˢ) Slice + +```go +func (s Charˢ) Slice(start, end uint64, ϟs *gfxapi.State) Charˢ +``` +Slice returns a sub-slice from the Charˢ using start and end indices. + +#### func (Charˢ) String + +```go +func (s Charˢ) String() string +``` +String returns a string description of the Charˢ slice. + +#### func (Charˢ) Write + +```go +func (dst Charˢ) Write(src []byte, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Charᵖ + +```go +type Charᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Charᵖ is a pointer to a byte element. + +#### func NewCharᵖ + +```go +func NewCharᵖ(addr memory.Pointer) Charᵖ +``` +NewCharᵖ returns a Charᵖ that points to addr in the application pool. + +#### func (*Charᵖ) Class + +```go +func (*Charᵖ) Class() binary.Class +``` + +#### func (Charᵖ) ElementSize + +```go +func (p Charᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charᵖ points to. + +#### func (Charᵖ) Read + +```go +func (p Charᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) byte +``` +Read reads and returns the byte element at the pointer. + +#### func (Charᵖ) Slice + +```go +func (p Charᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Charˢ +``` +Slice returns a new Charˢ from the pointer using start and end indices. + +#### func (Charᵖ) String + +```go +func (p Charᵖ) String() string +``` +String returns a string description of the Charᵖ pointer. + +#### func (Charᵖ) StringSlice + +```go +func (p Charᵖ) StringSlice(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, incNullTerm bool) Charˢ +``` +StringSlice returns a slice starting at p and ending at the first 0 byte +null-terminator. If incNullTerm is true then the null-terminator is included in +the slice. + +#### func (Charᵖ) Write + +```go +func (p Charᵖ) Write(value byte, ϟs *gfxapi.State) +``` +Write writes value to the byte element at the pointer. + +#### type Charᵖˢ + +```go +type Charᵖˢ struct { + binary.Generate + SliceInfo +} +``` + +Charᵖˢ is a slice of Charᵖ. + +#### func AsCharᵖˢ + +```go +func AsCharᵖˢ(s Slice, ϟs *gfxapi.State) Charᵖˢ +``` +AsCharᵖˢ returns s cast to a Charᵖˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeCharᵖˢ + +```go +func MakeCharᵖˢ(count uint64, ϟs *gfxapi.State) Charᵖˢ +``` +MakeCharᵖˢ returns a Charᵖˢ backed by a new memory pool. + +#### func (*Charᵖˢ) Class -#### func NewCmdArrayOfFloat +```go +func (*Charᵖˢ) Class() binary.Class +``` + +#### func (Charᵖˢ) Clone + +```go +func (s Charᵖˢ) Clone(ϟs *gfxapi.State) Charᵖˢ +``` +Clone returns a copy of the Charᵖˢ in a new memory pool. + +#### func (Charᵖˢ) Copy ```go -func NewCmdArrayOfFloat( - pResult F32Array, -) *CmdArrayOfFloat +func (dst Charᵖˢ) Copy(src Charᵖˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Charᵖˢ) ``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. -#### func (*CmdArrayOfFloat) API +#### func (Charᵖˢ) Decoder ```go -func (c *CmdArrayOfFloat) API() gfxapi.API +func (s Charᵖˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder ``` +Decoder returns a memory decoder for the slice. -#### func (*CmdArrayOfFloat) Class +#### func (Charᵖˢ) ElementSize ```go -func (*CmdArrayOfFloat) Class() binary.Class +func (s Charᵖˢ) ElementSize(ϟs *gfxapi.State) uint64 ``` +ElementSize returns the size in bytes of an element that Charᵖˢ points to. -#### func (*CmdArrayOfFloat) Flags +#### func (Charᵖˢ) Encoder ```go -func (c *CmdArrayOfFloat) Flags() atom.Flags +func (s Charᵖˢ) Encoder(ϟs *gfxapi.State) binary.Encoder ``` +Encoder returns a memory encoder for the slice. -#### func (*CmdArrayOfFloat) Mutate +#### func (Charᵖˢ) Index ```go -func (ϟa *CmdArrayOfFloat) Mutate(ϟs *gfxapi.State) error +func (s Charᵖˢ) Index(i uint64, ϟs *gfxapi.State) Charᵖᵖ ``` +Index returns a Charᵖᵖ to the i'th element in this Charᵖˢ. -#### func (*CmdArrayOfFloat) Replay +#### func (Charᵖˢ) Range ```go -func (ϟa *CmdArrayOfFloat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (s Charᵖˢ) Range(ϟs *gfxapi.State) memory.Range ``` +Range returns the memory range this slice represents in the underlying pool. -#### func (*CmdArrayOfFloat) String +#### func (Charᵖˢ) Read ```go -func (c *CmdArrayOfFloat) String() string +func (s Charᵖˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []Charᵖ ``` +Read reads and returns all the Charᵖ elements in this Charᵖˢ. -#### func (*CmdArrayOfFloat) TypeID +#### func (Charᵖˢ) ResourceID ```go -func (c *CmdArrayOfFloat) TypeID() atom.TypeID +func (s Charᵖˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID ``` +ResourceID returns an identifier to a resource representing the data of this +slice. -#### type CmdArrayOfFloat_Postback +#### func (Charᵖˢ) Slice ```go -type CmdArrayOfFloat_Postback struct { - Result F32Array +func (s Charᵖˢ) Slice(start, end uint64, ϟs *gfxapi.State) Charᵖˢ +``` +Slice returns a sub-slice from the Charᵖˢ using start and end indices. + +#### func (Charᵖˢ) String + +```go +func (s Charᵖˢ) String() string +``` +String returns a string description of the Charᵖˢ slice. + +#### func (Charᵖˢ) Write + +```go +func (dst Charᵖˢ) Write(src []Charᵖ, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Charᵖᵖ + +```go +type Charᵖᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID } ``` +Charᵖᵖ is a pointer to a Charᵖ element. Note: Pointers are stored differently +between the application pool and internal pools. + + * The application pool stores pointers as an address an architecture-dependant size. + * Internal pools store pointers as an 64-bit unsigned address and a 32-bit unsigned + pool identifier. -#### func (*CmdArrayOfFloat_Postback) Decode +#### func NewCharᵖᵖ ```go -func (o *CmdArrayOfFloat_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func NewCharᵖᵖ(addr memory.Pointer) Charᵖᵖ ``` +NewCharᵖᵖ returns a Charᵖᵖ that points to addr in the application pool. + +#### func (*Charᵖᵖ) Class + +```go +func (*Charᵖᵖ) Class() binary.Class +``` + +#### func (Charᵖᵖ) ElementSize + +```go +func (p Charᵖᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Charᵖᵖ points to. + +#### func (Charᵖᵖ) Read + +```go +func (p Charᵖᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) Charᵖ +``` +Read reads and returns the Charᵖ element at the pointer. + +#### func (Charᵖᵖ) Slice + +```go +func (p Charᵖᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Charᵖˢ +``` +Slice returns a new Charᵖˢ from the pointer using start and end indices. + +#### func (Charᵖᵖ) String + +```go +func (p Charᵖᵖ) String() string +``` +String returns a string description of the Charᵖᵖ pointer. + +#### func (Charᵖᵖ) Write + +```go +func (p Charᵖᵖ) Write(value Charᵖ, ϟs *gfxapi.State) +``` +Write writes value to the Charᵖ element at the pointer. #### type CmdBool ```go type CmdBool struct { binary.Generate + Result bool } ``` @@ -125,9 +591,7 @@ CmdBool #### func NewCmdBool ```go -func NewCmdBool( - pResult bool, -) *CmdBool +func NewCmdBool(Result bool) *CmdBool ``` #### func (*CmdBool) API @@ -136,6 +600,22 @@ func NewCmdBool( func (c *CmdBool) API() gfxapi.API ``` +#### func (*CmdBool) AddRead + +```go +func (a *CmdBool) AddRead(rng memory.Range, id binary.ID) *CmdBool +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdBool pointer is returned so that calls can be chained. + +#### func (*CmdBool) AddWrite + +```go +func (a *CmdBool) AddWrite(rng memory.Range, id binary.ID) *CmdBool +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdBool pointer is returned so that calls can be chained. + #### func (*CmdBool) Class ```go @@ -151,19 +631,25 @@ func (c *CmdBool) Flags() atom.Flags #### func (*CmdBool) Mutate ```go -func (ϟa *CmdBool) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdBool) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdBool) Observations + +```go +func (a *CmdBool) Observations() *atom.Observations ``` #### func (*CmdBool) Replay ```go -func (ϟa *CmdBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdBool) String ```go -func (c *CmdBool) String() string +func (a *CmdBool) String() string ``` #### func (*CmdBool) TypeID @@ -172,19 +658,347 @@ func (c *CmdBool) String() string func (c *CmdBool) TypeID() atom.TypeID ``` -#### type CmdBool_Postback +#### type CmdCharptrToString ```go -type CmdBool_Postback struct { - Result bool +type CmdCharptrToString struct { + binary.Generate + + S Charᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdCharptrToString +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdCharptrToString + +```go +func NewCmdCharptrToString(S memory.Pointer) *CmdCharptrToString +``` + +#### func (*CmdCharptrToString) API + +```go +func (c *CmdCharptrToString) API() gfxapi.API +``` + +#### func (*CmdCharptrToString) AddRead + +```go +func (a *CmdCharptrToString) AddRead(rng memory.Range, id binary.ID) *CmdCharptrToString +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdCharptrToString pointer is returned so that calls can be +chained. + +#### func (*CmdCharptrToString) AddWrite + +```go +func (a *CmdCharptrToString) AddWrite(rng memory.Range, id binary.ID) *CmdCharptrToString +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdCharptrToString pointer is returned so that calls can be +chained. + +#### func (*CmdCharptrToString) Class + +```go +func (*CmdCharptrToString) Class() binary.Class +``` + +#### func (*CmdCharptrToString) Flags + +```go +func (c *CmdCharptrToString) Flags() atom.Flags +``` + +#### func (*CmdCharptrToString) Mutate + +```go +func (ϟa *CmdCharptrToString) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdCharptrToString) Observations + +```go +func (a *CmdCharptrToString) Observations() *atom.Observations +``` + +#### func (*CmdCharptrToString) Replay + +```go +func (ϟa *CmdCharptrToString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdCharptrToString) String + +```go +func (a *CmdCharptrToString) String() string +``` + +#### func (*CmdCharptrToString) TypeID + +```go +func (c *CmdCharptrToString) TypeID() atom.TypeID +``` + +#### type CmdCharsliceToString + +```go +type CmdCharsliceToString struct { + binary.Generate + + S Charᵖ + Len uint32 +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdCharsliceToString +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdCharsliceToString + +```go +func NewCmdCharsliceToString(S memory.Pointer, Len uint32) *CmdCharsliceToString +``` + +#### func (*CmdCharsliceToString) API + +```go +func (c *CmdCharsliceToString) API() gfxapi.API +``` + +#### func (*CmdCharsliceToString) AddRead + +```go +func (a *CmdCharsliceToString) AddRead(rng memory.Range, id binary.ID) *CmdCharsliceToString +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdCharsliceToString pointer is returned so that calls can be +chained. + +#### func (*CmdCharsliceToString) AddWrite + +```go +func (a *CmdCharsliceToString) AddWrite(rng memory.Range, id binary.ID) *CmdCharsliceToString +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdCharsliceToString pointer is returned so that calls can be +chained. + +#### func (*CmdCharsliceToString) Class + +```go +func (*CmdCharsliceToString) Class() binary.Class +``` + +#### func (*CmdCharsliceToString) Flags + +```go +func (c *CmdCharsliceToString) Flags() atom.Flags +``` + +#### func (*CmdCharsliceToString) Mutate + +```go +func (ϟa *CmdCharsliceToString) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdCharsliceToString) Observations + +```go +func (a *CmdCharsliceToString) Observations() *atom.Observations +``` + +#### func (*CmdCharsliceToString) Replay + +```go +func (ϟa *CmdCharsliceToString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdCharsliceToString) String + +```go +func (a *CmdCharsliceToString) String() string +``` + +#### func (*CmdCharsliceToString) TypeID + +```go +func (c *CmdCharsliceToString) TypeID() atom.TypeID +``` + +#### type CmdClone + +```go +type CmdClone struct { + binary.Generate + + Src U8ᵖ + Cnt uint32 +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdClone +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdClone + +```go +func NewCmdClone(Src memory.Pointer, Cnt uint32) *CmdClone +``` + +#### func (*CmdClone) API + +```go +func (c *CmdClone) API() gfxapi.API +``` + +#### func (*CmdClone) AddRead + +```go +func (a *CmdClone) AddRead(rng memory.Range, id binary.ID) *CmdClone +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdClone pointer is returned so that calls can be chained. + +#### func (*CmdClone) AddWrite + +```go +func (a *CmdClone) AddWrite(rng memory.Range, id binary.ID) *CmdClone +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdClone pointer is returned so that calls can be chained. + +#### func (*CmdClone) Class + +```go +func (*CmdClone) Class() binary.Class +``` + +#### func (*CmdClone) Flags + +```go +func (c *CmdClone) Flags() atom.Flags +``` + +#### func (*CmdClone) Mutate + +```go +func (ϟa *CmdClone) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdClone) Observations + +```go +func (a *CmdClone) Observations() *atom.Observations +``` + +#### func (*CmdClone) Replay + +```go +func (ϟa *CmdClone) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdClone) String + +```go +func (a *CmdClone) String() string +``` + +#### func (*CmdClone) TypeID + +```go +func (c *CmdClone) TypeID() atom.TypeID +``` + +#### type CmdCopy + +```go +type CmdCopy struct { + binary.Generate + + Src U8ᵖ + Cnt uint32 } ``` +////////////////////////////////////////////////////////////////////////////// +CmdCopy +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdCopy + +```go +func NewCmdCopy(Src memory.Pointer, Cnt uint32) *CmdCopy +``` + +#### func (*CmdCopy) API + +```go +func (c *CmdCopy) API() gfxapi.API +``` + +#### func (*CmdCopy) AddRead + +```go +func (a *CmdCopy) AddRead(rng memory.Range, id binary.ID) *CmdCopy +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdCopy pointer is returned so that calls can be chained. -#### func (*CmdBool_Postback) Decode +#### func (*CmdCopy) AddWrite ```go -func (o *CmdBool_Postback) Decode(d binary.Decoder) error +func (a *CmdCopy) AddWrite(rng memory.Range, id binary.ID) *CmdCopy +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdCopy pointer is returned so that calls can be chained. + +#### func (*CmdCopy) Class + +```go +func (*CmdCopy) Class() binary.Class +``` + +#### func (*CmdCopy) Flags + +```go +func (c *CmdCopy) Flags() atom.Flags +``` + +#### func (*CmdCopy) Mutate + +```go +func (ϟa *CmdCopy) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdCopy) Observations + +```go +func (a *CmdCopy) Observations() *atom.Observations +``` + +#### func (*CmdCopy) Replay + +```go +func (ϟa *CmdCopy) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdCopy) String + +```go +func (a *CmdCopy) String() string +``` + +#### func (*CmdCopy) TypeID + +```go +func (c *CmdCopy) TypeID() atom.TypeID ``` #### type CmdF32 @@ -192,6 +1006,7 @@ func (o *CmdBool_Postback) Decode(d binary.Decoder) error ```go type CmdF32 struct { binary.Generate + Result float32 } ``` @@ -203,9 +1018,7 @@ CmdF32 #### func NewCmdF32 ```go -func NewCmdF32( - pResult float32, -) *CmdF32 +func NewCmdF32(Result float32) *CmdF32 ``` #### func (*CmdF32) API @@ -214,55 +1027,62 @@ func NewCmdF32( func (c *CmdF32) API() gfxapi.API ``` -#### func (*CmdF32) Class +#### func (*CmdF32) AddRead ```go -func (*CmdF32) Class() binary.Class +func (a *CmdF32) AddRead(rng memory.Range, id binary.ID) *CmdF32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdF32 pointer is returned so that calls can be chained. -#### func (*CmdF32) Flags +#### func (*CmdF32) AddWrite ```go -func (c *CmdF32) Flags() atom.Flags +func (a *CmdF32) AddWrite(rng memory.Range, id binary.ID) *CmdF32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdF32 pointer is returned so that calls can be chained. -#### func (*CmdF32) Mutate +#### func (*CmdF32) Class ```go -func (ϟa *CmdF32) Mutate(ϟs *gfxapi.State) error +func (*CmdF32) Class() binary.Class ``` -#### func (*CmdF32) Replay +#### func (*CmdF32) Flags ```go -func (ϟa *CmdF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdF32) Flags() atom.Flags ``` -#### func (*CmdF32) String +#### func (*CmdF32) Mutate ```go -func (c *CmdF32) String() string +func (ϟa *CmdF32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdF32) TypeID +#### func (*CmdF32) Observations ```go -func (c *CmdF32) TypeID() atom.TypeID +func (a *CmdF32) Observations() *atom.Observations ``` -#### type CmdF32_Postback +#### func (*CmdF32) Replay ```go -type CmdF32_Postback struct { - Result float32 -} +func (ϟa *CmdF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdF32) String + +```go +func (a *CmdF32) String() string +``` -#### func (*CmdF32_Postback) Decode +#### func (*CmdF32) TypeID ```go -func (o *CmdF32_Postback) Decode(d binary.Decoder) error +func (c *CmdF32) TypeID() atom.TypeID ``` #### type CmdF64 @@ -270,6 +1090,7 @@ func (o *CmdF32_Postback) Decode(d binary.Decoder) error ```go type CmdF64 struct { binary.Generate + Result float64 } ``` @@ -281,9 +1102,7 @@ CmdF64 #### func NewCmdF64 ```go -func NewCmdF64( - pResult float64, -) *CmdF64 +func NewCmdF64(Result float64) *CmdF64 ``` #### func (*CmdF64) API @@ -292,6 +1111,22 @@ func NewCmdF64( func (c *CmdF64) API() gfxapi.API ``` +#### func (*CmdF64) AddRead + +```go +func (a *CmdF64) AddRead(rng memory.Range, id binary.ID) *CmdF64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdF64 pointer is returned so that calls can be chained. + +#### func (*CmdF64) AddWrite + +```go +func (a *CmdF64) AddWrite(rng memory.Range, id binary.ID) *CmdF64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdF64 pointer is returned so that calls can be chained. + #### func (*CmdF64) Class ```go @@ -307,19 +1142,25 @@ func (c *CmdF64) Flags() atom.Flags #### func (*CmdF64) Mutate ```go -func (ϟa *CmdF64) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdF64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdF64) Observations + +```go +func (a *CmdF64) Observations() *atom.Observations ``` #### func (*CmdF64) Replay ```go -func (ϟa *CmdF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdF64) String ```go -func (c *CmdF64) String() string +func (a *CmdF64) String() string ``` #### func (*CmdF64) TypeID @@ -328,19 +1169,88 @@ func (c *CmdF64) String() string func (c *CmdF64) TypeID() atom.TypeID ``` -#### type CmdF64_Postback +#### type CmdMake ```go -type CmdF64_Postback struct { - Result float64 +type CmdMake struct { + binary.Generate + + Cnt uint32 } ``` +////////////////////////////////////////////////////////////////////////////// +CmdMake +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdMake + +```go +func NewCmdMake(Cnt uint32) *CmdMake +``` + +#### func (*CmdMake) API + +```go +func (c *CmdMake) API() gfxapi.API +``` + +#### func (*CmdMake) AddRead + +```go +func (a *CmdMake) AddRead(rng memory.Range, id binary.ID) *CmdMake +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdMake pointer is returned so that calls can be chained. + +#### func (*CmdMake) AddWrite + +```go +func (a *CmdMake) AddWrite(rng memory.Range, id binary.ID) *CmdMake +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdMake pointer is returned so that calls can be chained. + +#### func (*CmdMake) Class -#### func (*CmdF64_Postback) Decode +```go +func (*CmdMake) Class() binary.Class +``` + +#### func (*CmdMake) Flags ```go -func (o *CmdF64_Postback) Decode(d binary.Decoder) error +func (c *CmdMake) Flags() atom.Flags +``` + +#### func (*CmdMake) Mutate + +```go +func (ϟa *CmdMake) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdMake) Observations + +```go +func (a *CmdMake) Observations() *atom.Observations +``` + +#### func (*CmdMake) Replay + +```go +func (ϟa *CmdMake) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdMake) String + +```go +func (a *CmdMake) String() string +``` + +#### func (*CmdMake) TypeID + +```go +func (c *CmdMake) TypeID() atom.TypeID ``` #### type CmdPointer @@ -348,7 +1258,8 @@ func (o *CmdF64_Postback) Decode(d binary.Decoder) error ```go type CmdPointer struct { binary.Generate - Result memory.Pointer + + Result Voidᵖ } ``` @@ -359,9 +1270,7 @@ CmdPointer #### func NewCmdPointer ```go -func NewCmdPointer( - pResult memory.Pointer, -) *CmdPointer +func NewCmdPointer(Result memory.Pointer) *CmdPointer ``` #### func (*CmdPointer) API @@ -370,6 +1279,22 @@ func NewCmdPointer( func (c *CmdPointer) API() gfxapi.API ``` +#### func (*CmdPointer) AddRead + +```go +func (a *CmdPointer) AddRead(rng memory.Range, id binary.ID) *CmdPointer +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdPointer pointer is returned so that calls can be chained. + +#### func (*CmdPointer) AddWrite + +```go +func (a *CmdPointer) AddWrite(rng memory.Range, id binary.ID) *CmdPointer +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdPointer pointer is returned so that calls can be chained. + #### func (*CmdPointer) Class ```go @@ -385,19 +1310,25 @@ func (c *CmdPointer) Flags() atom.Flags #### func (*CmdPointer) Mutate ```go -func (ϟa *CmdPointer) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdPointer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdPointer) Observations + +```go +func (a *CmdPointer) Observations() *atom.Observations ``` #### func (*CmdPointer) Replay ```go -func (ϟa *CmdPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdPointer) String ```go -func (c *CmdPointer) String() string +func (a *CmdPointer) String() string ``` #### func (*CmdPointer) TypeID @@ -406,19 +1337,88 @@ func (c *CmdPointer) String() string func (c *CmdPointer) TypeID() atom.TypeID ``` -#### type CmdPointer_Postback +#### type CmdRemapped ```go -type CmdPointer_Postback struct { - Result []byte +type CmdRemapped struct { + binary.Generate + + Result remapped } ``` +////////////////////////////////////////////////////////////////////////////// +CmdRemapped +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdRemapped + +```go +func NewCmdRemapped(Result remapped) *CmdRemapped +``` -#### func (*CmdPointer_Postback) Decode +#### func (*CmdRemapped) API ```go -func (o *CmdPointer_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *CmdRemapped) API() gfxapi.API +``` + +#### func (*CmdRemapped) AddRead + +```go +func (a *CmdRemapped) AddRead(rng memory.Range, id binary.ID) *CmdRemapped +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdRemapped pointer is returned so that calls can be chained. + +#### func (*CmdRemapped) AddWrite + +```go +func (a *CmdRemapped) AddWrite(rng memory.Range, id binary.ID) *CmdRemapped +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdRemapped pointer is returned so that calls can be chained. + +#### func (*CmdRemapped) Class + +```go +func (*CmdRemapped) Class() binary.Class +``` + +#### func (*CmdRemapped) Flags + +```go +func (c *CmdRemapped) Flags() atom.Flags +``` + +#### func (*CmdRemapped) Mutate + +```go +func (ϟa *CmdRemapped) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdRemapped) Observations + +```go +func (a *CmdRemapped) Observations() *atom.Observations +``` + +#### func (*CmdRemapped) Replay + +```go +func (ϟa *CmdRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdRemapped) String + +```go +func (a *CmdRemapped) String() string +``` + +#### func (*CmdRemapped) TypeID + +```go +func (c *CmdRemapped) TypeID() atom.TypeID ``` #### type CmdS16 @@ -426,6 +1426,7 @@ func (o *CmdPointer_Postback) Decode(result_cnt uint64, d binary.Decoder) error ```go type CmdS16 struct { binary.Generate + Result int16 } ``` @@ -437,9 +1438,7 @@ CmdS16 #### func NewCmdS16 ```go -func NewCmdS16( - pResult int16, -) *CmdS16 +func NewCmdS16(Result int16) *CmdS16 ``` #### func (*CmdS16) API @@ -448,55 +1447,62 @@ func NewCmdS16( func (c *CmdS16) API() gfxapi.API ``` -#### func (*CmdS16) Class +#### func (*CmdS16) AddRead ```go -func (*CmdS16) Class() binary.Class +func (a *CmdS16) AddRead(rng memory.Range, id binary.ID) *CmdS16 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdS16 pointer is returned so that calls can be chained. -#### func (*CmdS16) Flags +#### func (*CmdS16) AddWrite ```go -func (c *CmdS16) Flags() atom.Flags +func (a *CmdS16) AddWrite(rng memory.Range, id binary.ID) *CmdS16 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdS16 pointer is returned so that calls can be chained. -#### func (*CmdS16) Mutate +#### func (*CmdS16) Class ```go -func (ϟa *CmdS16) Mutate(ϟs *gfxapi.State) error +func (*CmdS16) Class() binary.Class ``` -#### func (*CmdS16) Replay +#### func (*CmdS16) Flags ```go -func (ϟa *CmdS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdS16) Flags() atom.Flags ``` -#### func (*CmdS16) String +#### func (*CmdS16) Mutate ```go -func (c *CmdS16) String() string +func (ϟa *CmdS16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdS16) TypeID +#### func (*CmdS16) Observations ```go -func (c *CmdS16) TypeID() atom.TypeID +func (a *CmdS16) Observations() *atom.Observations ``` -#### type CmdS16_Postback +#### func (*CmdS16) Replay ```go -type CmdS16_Postback struct { - Result int16 -} +func (ϟa *CmdS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdS16) String -#### func (*CmdS16_Postback) Decode +```go +func (a *CmdS16) String() string +``` + +#### func (*CmdS16) TypeID ```go -func (o *CmdS16_Postback) Decode(d binary.Decoder) error +func (c *CmdS16) TypeID() atom.TypeID ``` #### type CmdS32 @@ -504,6 +1510,7 @@ func (o *CmdS16_Postback) Decode(d binary.Decoder) error ```go type CmdS32 struct { binary.Generate + Result int32 } ``` @@ -515,9 +1522,7 @@ CmdS32 #### func NewCmdS32 ```go -func NewCmdS32( - pResult int32, -) *CmdS32 +func NewCmdS32(Result int32) *CmdS32 ``` #### func (*CmdS32) API @@ -526,55 +1531,62 @@ func NewCmdS32( func (c *CmdS32) API() gfxapi.API ``` -#### func (*CmdS32) Class +#### func (*CmdS32) AddRead ```go -func (*CmdS32) Class() binary.Class +func (a *CmdS32) AddRead(rng memory.Range, id binary.ID) *CmdS32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdS32 pointer is returned so that calls can be chained. -#### func (*CmdS32) Flags +#### func (*CmdS32) AddWrite ```go -func (c *CmdS32) Flags() atom.Flags +func (a *CmdS32) AddWrite(rng memory.Range, id binary.ID) *CmdS32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdS32 pointer is returned so that calls can be chained. -#### func (*CmdS32) Mutate +#### func (*CmdS32) Class ```go -func (ϟa *CmdS32) Mutate(ϟs *gfxapi.State) error +func (*CmdS32) Class() binary.Class ``` -#### func (*CmdS32) Replay +#### func (*CmdS32) Flags ```go -func (ϟa *CmdS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdS32) Flags() atom.Flags ``` -#### func (*CmdS32) String +#### func (*CmdS32) Mutate ```go -func (c *CmdS32) String() string +func (ϟa *CmdS32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdS32) TypeID +#### func (*CmdS32) Observations ```go -func (c *CmdS32) TypeID() atom.TypeID +func (a *CmdS32) Observations() *atom.Observations ``` -#### type CmdS32_Postback +#### func (*CmdS32) Replay ```go -type CmdS32_Postback struct { - Result int32 -} +func (ϟa *CmdS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdS32) String -#### func (*CmdS32_Postback) Decode +```go +func (a *CmdS32) String() string +``` + +#### func (*CmdS32) TypeID ```go -func (o *CmdS32_Postback) Decode(d binary.Decoder) error +func (c *CmdS32) TypeID() atom.TypeID ``` #### type CmdS64 @@ -582,6 +1594,7 @@ func (o *CmdS32_Postback) Decode(d binary.Decoder) error ```go type CmdS64 struct { binary.Generate + Result int64 } ``` @@ -593,9 +1606,7 @@ CmdS64 #### func NewCmdS64 ```go -func NewCmdS64( - pResult int64, -) *CmdS64 +func NewCmdS64(Result int64) *CmdS64 ``` #### func (*CmdS64) API @@ -604,55 +1615,62 @@ func NewCmdS64( func (c *CmdS64) API() gfxapi.API ``` -#### func (*CmdS64) Class +#### func (*CmdS64) AddRead ```go -func (*CmdS64) Class() binary.Class +func (a *CmdS64) AddRead(rng memory.Range, id binary.ID) *CmdS64 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdS64 pointer is returned so that calls can be chained. -#### func (*CmdS64) Flags +#### func (*CmdS64) AddWrite ```go -func (c *CmdS64) Flags() atom.Flags +func (a *CmdS64) AddWrite(rng memory.Range, id binary.ID) *CmdS64 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdS64 pointer is returned so that calls can be chained. -#### func (*CmdS64) Mutate +#### func (*CmdS64) Class ```go -func (ϟa *CmdS64) Mutate(ϟs *gfxapi.State) error +func (*CmdS64) Class() binary.Class ``` -#### func (*CmdS64) Replay +#### func (*CmdS64) Flags ```go -func (ϟa *CmdS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdS64) Flags() atom.Flags ``` -#### func (*CmdS64) String +#### func (*CmdS64) Mutate ```go -func (c *CmdS64) String() string +func (ϟa *CmdS64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdS64) TypeID +#### func (*CmdS64) Observations ```go -func (c *CmdS64) TypeID() atom.TypeID +func (a *CmdS64) Observations() *atom.Observations ``` -#### type CmdS64_Postback +#### func (*CmdS64) Replay ```go -type CmdS64_Postback struct { - Result int64 -} +func (ϟa *CmdS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdS64) String -#### func (*CmdS64_Postback) Decode +```go +func (a *CmdS64) String() string +``` + +#### func (*CmdS64) TypeID ```go -func (o *CmdS64_Postback) Decode(d binary.Decoder) error +func (c *CmdS64) TypeID() atom.TypeID ``` #### type CmdS8 @@ -660,6 +1678,7 @@ func (o *CmdS64_Postback) Decode(d binary.Decoder) error ```go type CmdS8 struct { binary.Generate + Result int8 } ``` @@ -671,9 +1690,7 @@ CmdS8 #### func NewCmdS8 ```go -func NewCmdS8( - pResult int8, -) *CmdS8 +func NewCmdS8(Result int8) *CmdS8 ``` #### func (*CmdS8) API @@ -682,6 +1699,22 @@ func NewCmdS8( func (c *CmdS8) API() gfxapi.API ``` +#### func (*CmdS8) AddRead + +```go +func (a *CmdS8) AddRead(rng memory.Range, id binary.ID) *CmdS8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdS8 pointer is returned so that calls can be chained. + +#### func (*CmdS8) AddWrite + +```go +func (a *CmdS8) AddWrite(rng memory.Range, id binary.ID) *CmdS8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdS8 pointer is returned so that calls can be chained. + #### func (*CmdS8) Class ```go @@ -697,19 +1730,25 @@ func (c *CmdS8) Flags() atom.Flags #### func (*CmdS8) Mutate ```go -func (ϟa *CmdS8) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdS8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdS8) Observations + +```go +func (a *CmdS8) Observations() *atom.Observations ``` #### func (*CmdS8) Replay ```go -func (ϟa *CmdS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdS8) String ```go -func (c *CmdS8) String() string +func (a *CmdS8) String() string ``` #### func (*CmdS8) TypeID @@ -718,19 +1757,89 @@ func (c *CmdS8) String() string func (c *CmdS8) TypeID() atom.TypeID ``` -#### type CmdS8_Postback +#### type CmdSliceCasts ```go -type CmdS8_Postback struct { - Result int8 +type CmdSliceCasts struct { + binary.Generate + + S U16ᵖ + L uint32 } ``` +////////////////////////////////////////////////////////////////////////////// +CmdSliceCasts +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdSliceCasts + +```go +func NewCmdSliceCasts(S memory.Pointer, L uint32) *CmdSliceCasts +``` + +#### func (*CmdSliceCasts) API + +```go +func (c *CmdSliceCasts) API() gfxapi.API +``` + +#### func (*CmdSliceCasts) AddRead + +```go +func (a *CmdSliceCasts) AddRead(rng memory.Range, id binary.ID) *CmdSliceCasts +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdSliceCasts pointer is returned so that calls can be chained. + +#### func (*CmdSliceCasts) AddWrite + +```go +func (a *CmdSliceCasts) AddWrite(rng memory.Range, id binary.ID) *CmdSliceCasts +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdSliceCasts pointer is returned so that calls can be chained. + +#### func (*CmdSliceCasts) Class + +```go +func (*CmdSliceCasts) Class() binary.Class +``` + +#### func (*CmdSliceCasts) Flags + +```go +func (c *CmdSliceCasts) Flags() atom.Flags +``` + +#### func (*CmdSliceCasts) Mutate + +```go +func (ϟa *CmdSliceCasts) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdSliceCasts) Observations + +```go +func (a *CmdSliceCasts) Observations() *atom.Observations +``` + +#### func (*CmdSliceCasts) Replay + +```go +func (ϟa *CmdSliceCasts) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdSliceCasts) String + +```go +func (a *CmdSliceCasts) String() string +``` -#### func (*CmdS8_Postback) Decode +#### func (*CmdSliceCasts) TypeID ```go -func (o *CmdS8_Postback) Decode(d binary.Decoder) error +func (c *CmdSliceCasts) TypeID() atom.TypeID ``` #### type CmdString @@ -738,6 +1847,7 @@ func (o *CmdS8_Postback) Decode(d binary.Decoder) error ```go type CmdString struct { binary.Generate + Result string } ``` @@ -749,9 +1859,7 @@ CmdString #### func NewCmdString ```go -func NewCmdString( - pResult string, -) *CmdString +func NewCmdString(Result string) *CmdString ``` #### func (*CmdString) API @@ -760,55 +1868,62 @@ func NewCmdString( func (c *CmdString) API() gfxapi.API ``` -#### func (*CmdString) Class +#### func (*CmdString) AddRead ```go -func (*CmdString) Class() binary.Class +func (a *CmdString) AddRead(rng memory.Range, id binary.ID) *CmdString ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdString pointer is returned so that calls can be chained. -#### func (*CmdString) Flags +#### func (*CmdString) AddWrite ```go -func (c *CmdString) Flags() atom.Flags +func (a *CmdString) AddWrite(rng memory.Range, id binary.ID) *CmdString ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdString pointer is returned so that calls can be chained. -#### func (*CmdString) Mutate +#### func (*CmdString) Class ```go -func (ϟa *CmdString) Mutate(ϟs *gfxapi.State) error +func (*CmdString) Class() binary.Class ``` -#### func (*CmdString) Replay +#### func (*CmdString) Flags ```go -func (ϟa *CmdString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdString) Flags() atom.Flags ``` -#### func (*CmdString) String +#### func (*CmdString) Mutate ```go -func (c *CmdString) String() string +func (ϟa *CmdString) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdString) TypeID +#### func (*CmdString) Observations ```go -func (c *CmdString) TypeID() atom.TypeID +func (a *CmdString) Observations() *atom.Observations ``` -#### type CmdString_Postback +#### func (*CmdString) Replay ```go -type CmdString_Postback struct { - Result string -} +func (ϟa *CmdString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdString) String -#### func (*CmdString_Postback) Decode +```go +func (a *CmdString) String() string +``` + +#### func (*CmdString) TypeID ```go -func (o *CmdString_Postback) Decode(result_cnt uint64, d binary.Decoder) error +func (c *CmdString) TypeID() atom.TypeID ``` #### type CmdU16 @@ -816,6 +1931,7 @@ func (o *CmdString_Postback) Decode(result_cnt uint64, d binary.Decoder) error ```go type CmdU16 struct { binary.Generate + Result uint16 } ``` @@ -827,9 +1943,7 @@ CmdU16 #### func NewCmdU16 ```go -func NewCmdU16( - pResult uint16, -) *CmdU16 +func NewCmdU16(Result uint16) *CmdU16 ``` #### func (*CmdU16) API @@ -838,55 +1952,62 @@ func NewCmdU16( func (c *CmdU16) API() gfxapi.API ``` -#### func (*CmdU16) Class +#### func (*CmdU16) AddRead ```go -func (*CmdU16) Class() binary.Class +func (a *CmdU16) AddRead(rng memory.Range, id binary.ID) *CmdU16 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdU16 pointer is returned so that calls can be chained. -#### func (*CmdU16) Flags +#### func (*CmdU16) AddWrite ```go -func (c *CmdU16) Flags() atom.Flags +func (a *CmdU16) AddWrite(rng memory.Range, id binary.ID) *CmdU16 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdU16 pointer is returned so that calls can be chained. -#### func (*CmdU16) Mutate +#### func (*CmdU16) Class ```go -func (ϟa *CmdU16) Mutate(ϟs *gfxapi.State) error +func (*CmdU16) Class() binary.Class ``` -#### func (*CmdU16) Replay +#### func (*CmdU16) Flags ```go -func (ϟa *CmdU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdU16) Flags() atom.Flags ``` -#### func (*CmdU16) String +#### func (*CmdU16) Mutate ```go -func (c *CmdU16) String() string +func (ϟa *CmdU16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdU16) TypeID +#### func (*CmdU16) Observations ```go -func (c *CmdU16) TypeID() atom.TypeID +func (a *CmdU16) Observations() *atom.Observations ``` -#### type CmdU16_Postback +#### func (*CmdU16) Replay ```go -type CmdU16_Postback struct { - Result uint16 -} +func (ϟa *CmdU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdU16) String -#### func (*CmdU16_Postback) Decode +```go +func (a *CmdU16) String() string +``` + +#### func (*CmdU16) TypeID ```go -func (o *CmdU16_Postback) Decode(d binary.Decoder) error +func (c *CmdU16) TypeID() atom.TypeID ``` #### type CmdU32 @@ -894,6 +2015,7 @@ func (o *CmdU16_Postback) Decode(d binary.Decoder) error ```go type CmdU32 struct { binary.Generate + Result uint32 } ``` @@ -905,9 +2027,7 @@ CmdU32 #### func NewCmdU32 ```go -func NewCmdU32( - pResult uint32, -) *CmdU32 +func NewCmdU32(Result uint32) *CmdU32 ``` #### func (*CmdU32) API @@ -916,55 +2036,62 @@ func NewCmdU32( func (c *CmdU32) API() gfxapi.API ``` -#### func (*CmdU32) Class +#### func (*CmdU32) AddRead ```go -func (*CmdU32) Class() binary.Class +func (a *CmdU32) AddRead(rng memory.Range, id binary.ID) *CmdU32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdU32 pointer is returned so that calls can be chained. -#### func (*CmdU32) Flags +#### func (*CmdU32) AddWrite ```go -func (c *CmdU32) Flags() atom.Flags +func (a *CmdU32) AddWrite(rng memory.Range, id binary.ID) *CmdU32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdU32 pointer is returned so that calls can be chained. -#### func (*CmdU32) Mutate +#### func (*CmdU32) Class ```go -func (ϟa *CmdU32) Mutate(ϟs *gfxapi.State) error +func (*CmdU32) Class() binary.Class ``` -#### func (*CmdU32) Replay +#### func (*CmdU32) Flags ```go -func (ϟa *CmdU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdU32) Flags() atom.Flags ``` -#### func (*CmdU32) String +#### func (*CmdU32) Mutate ```go -func (c *CmdU32) String() string +func (ϟa *CmdU32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdU32) TypeID +#### func (*CmdU32) Observations ```go -func (c *CmdU32) TypeID() atom.TypeID +func (a *CmdU32) Observations() *atom.Observations ``` -#### type CmdU32_Postback +#### func (*CmdU32) Replay ```go -type CmdU32_Postback struct { - Result uint32 -} +func (ϟa *CmdU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdU32) String + +```go +func (a *CmdU32) String() string +``` -#### func (*CmdU32_Postback) Decode +#### func (*CmdU32) TypeID ```go -func (o *CmdU32_Postback) Decode(d binary.Decoder) error +func (c *CmdU32) TypeID() atom.TypeID ``` #### type CmdU64 @@ -972,6 +2099,7 @@ func (o *CmdU32_Postback) Decode(d binary.Decoder) error ```go type CmdU64 struct { binary.Generate + Result uint64 } ``` @@ -983,9 +2111,7 @@ CmdU64 #### func NewCmdU64 ```go -func NewCmdU64( - pResult uint64, -) *CmdU64 +func NewCmdU64(Result uint64) *CmdU64 ``` #### func (*CmdU64) API @@ -994,55 +2120,62 @@ func NewCmdU64( func (c *CmdU64) API() gfxapi.API ``` -#### func (*CmdU64) Class +#### func (*CmdU64) AddRead ```go -func (*CmdU64) Class() binary.Class +func (a *CmdU64) AddRead(rng memory.Range, id binary.ID) *CmdU64 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdU64 pointer is returned so that calls can be chained. -#### func (*CmdU64) Flags +#### func (*CmdU64) AddWrite ```go -func (c *CmdU64) Flags() atom.Flags +func (a *CmdU64) AddWrite(rng memory.Range, id binary.ID) *CmdU64 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdU64 pointer is returned so that calls can be chained. -#### func (*CmdU64) Mutate +#### func (*CmdU64) Class ```go -func (ϟa *CmdU64) Mutate(ϟs *gfxapi.State) error +func (*CmdU64) Class() binary.Class ``` -#### func (*CmdU64) Replay +#### func (*CmdU64) Flags ```go -func (ϟa *CmdU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdU64) Flags() atom.Flags ``` -#### func (*CmdU64) String +#### func (*CmdU64) Mutate ```go -func (c *CmdU64) String() string +func (ϟa *CmdU64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdU64) TypeID +#### func (*CmdU64) Observations ```go -func (c *CmdU64) TypeID() atom.TypeID +func (a *CmdU64) Observations() *atom.Observations ``` -#### type CmdU64_Postback +#### func (*CmdU64) Replay ```go -type CmdU64_Postback struct { - Result uint64 -} +func (ϟa *CmdU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdU64) String + +```go +func (a *CmdU64) String() string +``` -#### func (*CmdU64_Postback) Decode +#### func (*CmdU64) TypeID ```go -func (o *CmdU64_Postback) Decode(d binary.Decoder) error +func (c *CmdU64) TypeID() atom.TypeID ``` #### type CmdU8 @@ -1050,6 +2183,7 @@ func (o *CmdU64_Postback) Decode(d binary.Decoder) error ```go type CmdU8 struct { binary.Generate + Result uint8 } ``` @@ -1061,9 +2195,7 @@ CmdU8 #### func NewCmdU8 ```go -func NewCmdU8( - pResult uint8, -) *CmdU8 +func NewCmdU8(Result uint8) *CmdU8 ``` #### func (*CmdU8) API @@ -1072,6 +2204,22 @@ func NewCmdU8( func (c *CmdU8) API() gfxapi.API ``` +#### func (*CmdU8) AddRead + +```go +func (a *CmdU8) AddRead(rng memory.Range, id binary.ID) *CmdU8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdU8 pointer is returned so that calls can be chained. + +#### func (*CmdU8) AddWrite + +```go +func (a *CmdU8) AddWrite(rng memory.Range, id binary.ID) *CmdU8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdU8 pointer is returned so that calls can be chained. + #### func (*CmdU8) Class ```go @@ -1087,19 +2235,25 @@ func (c *CmdU8) Flags() atom.Flags #### func (*CmdU8) Mutate ```go -func (ϟa *CmdU8) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdU8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdU8) Observations + +```go +func (a *CmdU8) Observations() *atom.Observations ``` #### func (*CmdU8) Replay ```go -func (ϟa *CmdU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdU8) String ```go -func (c *CmdU8) String() string +func (a *CmdU8) String() string ``` #### func (*CmdU8) TypeID @@ -1108,19 +2262,260 @@ func (c *CmdU8) String() string func (c *CmdU8) TypeID() atom.TypeID ``` -#### type CmdU8_Postback +#### type CmdUnknownRet ```go -type CmdU8_Postback struct { - Result uint8 +type CmdUnknownRet struct { + binary.Generate + + Result int64 +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdUnknownRet +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdUnknownRet + +```go +func NewCmdUnknownRet(Result int64) *CmdUnknownRet +``` + +#### func (*CmdUnknownRet) API + +```go +func (c *CmdUnknownRet) API() gfxapi.API +``` + +#### func (*CmdUnknownRet) AddRead + +```go +func (a *CmdUnknownRet) AddRead(rng memory.Range, id binary.ID) *CmdUnknownRet +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdUnknownRet pointer is returned so that calls can be chained. + +#### func (*CmdUnknownRet) AddWrite + +```go +func (a *CmdUnknownRet) AddWrite(rng memory.Range, id binary.ID) *CmdUnknownRet +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdUnknownRet pointer is returned so that calls can be chained. + +#### func (*CmdUnknownRet) Class + +```go +func (*CmdUnknownRet) Class() binary.Class +``` + +#### func (*CmdUnknownRet) Flags + +```go +func (c *CmdUnknownRet) Flags() atom.Flags +``` + +#### func (*CmdUnknownRet) Mutate + +```go +func (ϟa *CmdUnknownRet) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdUnknownRet) Observations + +```go +func (a *CmdUnknownRet) Observations() *atom.Observations +``` + +#### func (*CmdUnknownRet) Replay + +```go +func (ϟa *CmdUnknownRet) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdUnknownRet) String + +```go +func (a *CmdUnknownRet) String() string +``` + +#### func (*CmdUnknownRet) TypeID + +```go +func (c *CmdUnknownRet) TypeID() atom.TypeID +``` + +#### type CmdUnknownWritePtr + +```go +type CmdUnknownWritePtr struct { + binary.Generate + + P Intᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdUnknownWritePtr +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdUnknownWritePtr + +```go +func NewCmdUnknownWritePtr(P memory.Pointer) *CmdUnknownWritePtr +``` + +#### func (*CmdUnknownWritePtr) API + +```go +func (c *CmdUnknownWritePtr) API() gfxapi.API +``` + +#### func (*CmdUnknownWritePtr) AddRead + +```go +func (a *CmdUnknownWritePtr) AddRead(rng memory.Range, id binary.ID) *CmdUnknownWritePtr +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdUnknownWritePtr pointer is returned so that calls can be +chained. + +#### func (*CmdUnknownWritePtr) AddWrite + +```go +func (a *CmdUnknownWritePtr) AddWrite(rng memory.Range, id binary.ID) *CmdUnknownWritePtr +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdUnknownWritePtr pointer is returned so that calls can be +chained. + +#### func (*CmdUnknownWritePtr) Class + +```go +func (*CmdUnknownWritePtr) Class() binary.Class +``` + +#### func (*CmdUnknownWritePtr) Flags + +```go +func (c *CmdUnknownWritePtr) Flags() atom.Flags +``` + +#### func (*CmdUnknownWritePtr) Mutate + +```go +func (ϟa *CmdUnknownWritePtr) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdUnknownWritePtr) Observations + +```go +func (a *CmdUnknownWritePtr) Observations() *atom.Observations +``` + +#### func (*CmdUnknownWritePtr) Replay + +```go +func (ϟa *CmdUnknownWritePtr) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdUnknownWritePtr) String + +```go +func (a *CmdUnknownWritePtr) String() string +``` + +#### func (*CmdUnknownWritePtr) TypeID + +```go +func (c *CmdUnknownWritePtr) TypeID() atom.TypeID +``` + +#### type CmdUnknownWriteSlice + +```go +type CmdUnknownWriteSlice struct { + binary.Generate + + A Intᵖ } ``` +////////////////////////////////////////////////////////////////////////////// +CmdUnknownWriteSlice +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdUnknownWriteSlice + +```go +func NewCmdUnknownWriteSlice(A memory.Pointer) *CmdUnknownWriteSlice +``` -#### func (*CmdU8_Postback) Decode +#### func (*CmdUnknownWriteSlice) API ```go -func (o *CmdU8_Postback) Decode(d binary.Decoder) error +func (c *CmdUnknownWriteSlice) API() gfxapi.API +``` + +#### func (*CmdUnknownWriteSlice) AddRead + +```go +func (a *CmdUnknownWriteSlice) AddRead(rng memory.Range, id binary.ID) *CmdUnknownWriteSlice +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdUnknownWriteSlice pointer is returned so that calls can be +chained. + +#### func (*CmdUnknownWriteSlice) AddWrite + +```go +func (a *CmdUnknownWriteSlice) AddWrite(rng memory.Range, id binary.ID) *CmdUnknownWriteSlice +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdUnknownWriteSlice pointer is returned so that calls can be +chained. + +#### func (*CmdUnknownWriteSlice) Class + +```go +func (*CmdUnknownWriteSlice) Class() binary.Class +``` + +#### func (*CmdUnknownWriteSlice) Flags + +```go +func (c *CmdUnknownWriteSlice) Flags() atom.Flags +``` + +#### func (*CmdUnknownWriteSlice) Mutate + +```go +func (ϟa *CmdUnknownWriteSlice) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdUnknownWriteSlice) Observations + +```go +func (a *CmdUnknownWriteSlice) Observations() *atom.Observations +``` + +#### func (*CmdUnknownWriteSlice) Replay + +```go +func (ϟa *CmdUnknownWriteSlice) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdUnknownWriteSlice) String + +```go +func (a *CmdUnknownWriteSlice) String() string +``` + +#### func (*CmdUnknownWriteSlice) TypeID + +```go +func (c *CmdUnknownWriteSlice) TypeID() atom.TypeID ``` #### type CmdVoid @@ -1147,6 +2542,22 @@ func NewCmdVoid() *CmdVoid func (c *CmdVoid) API() gfxapi.API ``` +#### func (*CmdVoid) AddRead + +```go +func (a *CmdVoid) AddRead(rng memory.Range, id binary.ID) *CmdVoid +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoid pointer is returned so that calls can be chained. + +#### func (*CmdVoid) AddWrite + +```go +func (a *CmdVoid) AddWrite(rng memory.Range, id binary.ID) *CmdVoid +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoid pointer is returned so that calls can be chained. + #### func (*CmdVoid) Class ```go @@ -1162,19 +2573,25 @@ func (c *CmdVoid) Flags() atom.Flags #### func (*CmdVoid) Mutate ```go -func (ϟa *CmdVoid) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoid) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoid) Observations + +```go +func (a *CmdVoid) Observations() *atom.Observations ``` #### func (*CmdVoid) Replay ```go -func (ϟa *CmdVoid) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoid) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoid) String ```go -func (c *CmdVoid) String() string +func (a *CmdVoid) String() string ``` #### func (*CmdVoid) TypeID @@ -1183,71 +2600,90 @@ func (c *CmdVoid) String() string func (c *CmdVoid) TypeID() atom.TypeID ``` -#### type CmdVoid3Arrays +#### type CmdVoid3InArrays ```go -type CmdVoid3Arrays struct { +type CmdVoid3InArrays struct { binary.Generate - A S8Array - B StringArray - C BoolArray + + A U8ᵖ + B U32ᵖ + C Intᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoid3Arrays +CmdVoid3InArrays ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoid3Arrays +#### func NewCmdVoid3InArrays + +```go +func NewCmdVoid3InArrays(A memory.Pointer, B memory.Pointer, C memory.Pointer) *CmdVoid3InArrays +``` + +#### func (*CmdVoid3InArrays) API ```go -func NewCmdVoid3Arrays( - pA S8Array, - pB StringArray, - pC BoolArray, -) *CmdVoid3Arrays +func (c *CmdVoid3InArrays) API() gfxapi.API ``` -#### func (*CmdVoid3Arrays) API +#### func (*CmdVoid3InArrays) AddRead ```go -func (c *CmdVoid3Arrays) API() gfxapi.API +func (a *CmdVoid3InArrays) AddRead(rng memory.Range, id binary.ID) *CmdVoid3InArrays ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoid3InArrays pointer is returned so that calls can be chained. -#### func (*CmdVoid3Arrays) Class +#### func (*CmdVoid3InArrays) AddWrite ```go -func (*CmdVoid3Arrays) Class() binary.Class +func (a *CmdVoid3InArrays) AddWrite(rng memory.Range, id binary.ID) *CmdVoid3InArrays ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoid3InArrays pointer is returned so that calls can be chained. -#### func (*CmdVoid3Arrays) Flags +#### func (*CmdVoid3InArrays) Class ```go -func (c *CmdVoid3Arrays) Flags() atom.Flags +func (*CmdVoid3InArrays) Class() binary.Class ``` -#### func (*CmdVoid3Arrays) Mutate +#### func (*CmdVoid3InArrays) Flags ```go -func (ϟa *CmdVoid3Arrays) Mutate(ϟs *gfxapi.State) error +func (c *CmdVoid3InArrays) Flags() atom.Flags ``` -#### func (*CmdVoid3Arrays) Replay +#### func (*CmdVoid3InArrays) Mutate ```go -func (ϟa *CmdVoid3Arrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoid3InArrays) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoid3Arrays) String +#### func (*CmdVoid3InArrays) Observations ```go -func (c *CmdVoid3Arrays) String() string +func (a *CmdVoid3InArrays) Observations() *atom.Observations ``` -#### func (*CmdVoid3Arrays) TypeID +#### func (*CmdVoid3InArrays) Replay ```go -func (c *CmdVoid3Arrays) TypeID() atom.TypeID +func (ϟa *CmdVoid3InArrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoid3InArrays) String + +```go +func (a *CmdVoid3InArrays) String() string +``` + +#### func (*CmdVoid3InArrays) TypeID + +```go +func (c *CmdVoid3InArrays) TypeID() atom.TypeID ``` #### type CmdVoid3Remapped @@ -1255,6 +2691,7 @@ func (c *CmdVoid3Arrays) TypeID() atom.TypeID ```go type CmdVoid3Remapped struct { binary.Generate + A remapped B remapped C remapped @@ -1268,11 +2705,7 @@ CmdVoid3Remapped #### func NewCmdVoid3Remapped ```go -func NewCmdVoid3Remapped( - pA remapped, - pB remapped, - pC remapped, -) *CmdVoid3Remapped +func NewCmdVoid3Remapped(A remapped, B remapped, C remapped) *CmdVoid3Remapped ``` #### func (*CmdVoid3Remapped) API @@ -1281,6 +2714,22 @@ func NewCmdVoid3Remapped( func (c *CmdVoid3Remapped) API() gfxapi.API ``` +#### func (*CmdVoid3Remapped) AddRead + +```go +func (a *CmdVoid3Remapped) AddRead(rng memory.Range, id binary.ID) *CmdVoid3Remapped +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoid3Remapped pointer is returned so that calls can be chained. + +#### func (*CmdVoid3Remapped) AddWrite + +```go +func (a *CmdVoid3Remapped) AddWrite(rng memory.Range, id binary.ID) *CmdVoid3Remapped +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoid3Remapped pointer is returned so that calls can be chained. + #### func (*CmdVoid3Remapped) Class ```go @@ -1296,19 +2745,25 @@ func (c *CmdVoid3Remapped) Flags() atom.Flags #### func (*CmdVoid3Remapped) Mutate ```go -func (ϟa *CmdVoid3Remapped) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoid3Remapped) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoid3Remapped) Observations + +```go +func (a *CmdVoid3Remapped) Observations() *atom.Observations ``` #### func (*CmdVoid3Remapped) Replay ```go -func (ϟa *CmdVoid3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoid3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoid3Remapped) String ```go -func (c *CmdVoid3Remapped) String() string +func (a *CmdVoid3Remapped) String() string ``` #### func (*CmdVoid3Remapped) TypeID @@ -1322,6 +2777,7 @@ func (c *CmdVoid3Remapped) TypeID() atom.TypeID ```go type CmdVoid3Strings struct { binary.Generate + A string B string C string @@ -1335,11 +2791,7 @@ CmdVoid3Strings #### func NewCmdVoid3Strings ```go -func NewCmdVoid3Strings( - pA string, - pB string, - pC string, -) *CmdVoid3Strings +func NewCmdVoid3Strings(A string, B string, C string) *CmdVoid3Strings ``` #### func (*CmdVoid3Strings) API @@ -1348,103 +2800,62 @@ func NewCmdVoid3Strings( func (c *CmdVoid3Strings) API() gfxapi.API ``` -#### func (*CmdVoid3Strings) Class - -```go -func (*CmdVoid3Strings) Class() binary.Class -``` - -#### func (*CmdVoid3Strings) Flags - -```go -func (c *CmdVoid3Strings) Flags() atom.Flags -``` - -#### func (*CmdVoid3Strings) Mutate +#### func (*CmdVoid3Strings) AddRead ```go -func (ϟa *CmdVoid3Strings) Mutate(ϟs *gfxapi.State) error +func (a *CmdVoid3Strings) AddRead(rng memory.Range, id binary.ID) *CmdVoid3Strings ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoid3Strings pointer is returned so that calls can be chained. -#### func (*CmdVoid3Strings) Replay +#### func (*CmdVoid3Strings) AddWrite ```go -func (ϟa *CmdVoid3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) -``` - -#### func (*CmdVoid3Strings) String - -```go -func (c *CmdVoid3Strings) String() string -``` - -#### func (*CmdVoid3Strings) TypeID - -```go -func (c *CmdVoid3Strings) TypeID() atom.TypeID -``` - -#### type CmdVoidArrayOfStrings - -```go -type CmdVoidArrayOfStrings struct { - binary.Generate - A StringArray -} +func (a *CmdVoid3Strings) AddWrite(rng memory.Range, id binary.ID) *CmdVoid3Strings ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoid3Strings pointer is returned so that calls can be chained. -////////////////////////////////////////////////////////////////////////////// -CmdVoidArrayOfStrings -////////////////////////////////////////////////////////////////////////////// - -#### func NewCmdVoidArrayOfStrings - -```go -func NewCmdVoidArrayOfStrings( - pA StringArray, -) *CmdVoidArrayOfStrings -``` - -#### func (*CmdVoidArrayOfStrings) API +#### func (*CmdVoid3Strings) Class ```go -func (c *CmdVoidArrayOfStrings) API() gfxapi.API +func (*CmdVoid3Strings) Class() binary.Class ``` -#### func (*CmdVoidArrayOfStrings) Class +#### func (*CmdVoid3Strings) Flags ```go -func (*CmdVoidArrayOfStrings) Class() binary.Class +func (c *CmdVoid3Strings) Flags() atom.Flags ``` -#### func (*CmdVoidArrayOfStrings) Flags +#### func (*CmdVoid3Strings) Mutate ```go -func (c *CmdVoidArrayOfStrings) Flags() atom.Flags +func (ϟa *CmdVoid3Strings) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidArrayOfStrings) Mutate +#### func (*CmdVoid3Strings) Observations ```go -func (ϟa *CmdVoidArrayOfStrings) Mutate(ϟs *gfxapi.State) error +func (a *CmdVoid3Strings) Observations() *atom.Observations ``` -#### func (*CmdVoidArrayOfStrings) Replay +#### func (*CmdVoid3Strings) Replay ```go -func (ϟa *CmdVoidArrayOfStrings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoid3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` -#### func (*CmdVoidArrayOfStrings) String +#### func (*CmdVoid3Strings) String ```go -func (c *CmdVoidArrayOfStrings) String() string +func (a *CmdVoid3Strings) String() string ``` -#### func (*CmdVoidArrayOfStrings) TypeID +#### func (*CmdVoid3Strings) TypeID ```go -func (c *CmdVoidArrayOfStrings) TypeID() atom.TypeID +func (c *CmdVoid3Strings) TypeID() atom.TypeID ``` #### type CmdVoidBool @@ -1452,6 +2863,7 @@ func (c *CmdVoidArrayOfStrings) TypeID() atom.TypeID ```go type CmdVoidBool struct { binary.Generate + A bool } ``` @@ -1463,9 +2875,7 @@ CmdVoidBool #### func NewCmdVoidBool ```go -func NewCmdVoidBool( - pA bool, -) *CmdVoidBool +func NewCmdVoidBool(A bool) *CmdVoidBool ``` #### func (*CmdVoidBool) API @@ -1474,6 +2884,22 @@ func NewCmdVoidBool( func (c *CmdVoidBool) API() gfxapi.API ``` +#### func (*CmdVoidBool) AddRead + +```go +func (a *CmdVoidBool) AddRead(rng memory.Range, id binary.ID) *CmdVoidBool +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidBool pointer is returned so that calls can be chained. + +#### func (*CmdVoidBool) AddWrite + +```go +func (a *CmdVoidBool) AddWrite(rng memory.Range, id binary.ID) *CmdVoidBool +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidBool pointer is returned so that calls can be chained. + #### func (*CmdVoidBool) Class ```go @@ -1489,19 +2915,25 @@ func (c *CmdVoidBool) Flags() atom.Flags #### func (*CmdVoidBool) Mutate ```go -func (ϟa *CmdVoidBool) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidBool) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidBool) Observations + +```go +func (a *CmdVoidBool) Observations() *atom.Observations ``` #### func (*CmdVoidBool) Replay ```go -func (ϟa *CmdVoidBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidBool) String ```go -func (c *CmdVoidBool) String() string +func (a *CmdVoidBool) String() string ``` #### func (*CmdVoidBool) TypeID @@ -1515,6 +2947,7 @@ func (c *CmdVoidBool) TypeID() atom.TypeID ```go type CmdVoidF32 struct { binary.Generate + A float32 } ``` @@ -1526,9 +2959,7 @@ CmdVoidF32 #### func NewCmdVoidF32 ```go -func NewCmdVoidF32( - pA float32, -) *CmdVoidF32 +func NewCmdVoidF32(A float32) *CmdVoidF32 ``` #### func (*CmdVoidF32) API @@ -1537,6 +2968,22 @@ func NewCmdVoidF32( func (c *CmdVoidF32) API() gfxapi.API ``` +#### func (*CmdVoidF32) AddRead + +```go +func (a *CmdVoidF32) AddRead(rng memory.Range, id binary.ID) *CmdVoidF32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidF32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidF32) AddWrite + +```go +func (a *CmdVoidF32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidF32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidF32 pointer is returned so that calls can be chained. + #### func (*CmdVoidF32) Class ```go @@ -1552,19 +2999,25 @@ func (c *CmdVoidF32) Flags() atom.Flags #### func (*CmdVoidF32) Mutate ```go -func (ϟa *CmdVoidF32) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidF32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidF32) Observations + +```go +func (a *CmdVoidF32) Observations() *atom.Observations ``` #### func (*CmdVoidF32) Replay ```go -func (ϟa *CmdVoidF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidF32) String ```go -func (c *CmdVoidF32) String() string +func (a *CmdVoidF32) String() string ``` #### func (*CmdVoidF32) TypeID @@ -1578,6 +3031,7 @@ func (c *CmdVoidF32) TypeID() atom.TypeID ```go type CmdVoidF64 struct { binary.Generate + A float64 } ``` @@ -1589,9 +3043,7 @@ CmdVoidF64 #### func NewCmdVoidF64 ```go -func NewCmdVoidF64( - pA float64, -) *CmdVoidF64 +func NewCmdVoidF64(A float64) *CmdVoidF64 ``` #### func (*CmdVoidF64) API @@ -1600,6 +3052,22 @@ func NewCmdVoidF64( func (c *CmdVoidF64) API() gfxapi.API ``` +#### func (*CmdVoidF64) AddRead + +```go +func (a *CmdVoidF64) AddRead(rng memory.Range, id binary.ID) *CmdVoidF64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidF64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidF64) AddWrite + +```go +func (a *CmdVoidF64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidF64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidF64 pointer is returned so that calls can be chained. + #### func (*CmdVoidF64) Class ```go @@ -1615,19 +3083,25 @@ func (c *CmdVoidF64) Flags() atom.Flags #### func (*CmdVoidF64) Mutate ```go -func (ϟa *CmdVoidF64) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidF64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidF64) Observations + +```go +func (a *CmdVoidF64) Observations() *atom.Observations ``` #### func (*CmdVoidF64) Replay ```go -func (ϟa *CmdVoidF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidF64) String ```go -func (c *CmdVoidF64) String() string +func (a *CmdVoidF64) String() string ``` #### func (*CmdVoidF64) TypeID @@ -1636,174 +3110,177 @@ func (c *CmdVoidF64) String() string func (c *CmdVoidF64) TypeID() atom.TypeID ``` -#### type CmdVoidOut3Remapped +#### type CmdVoidInArrayOfPointers ```go -type CmdVoidOut3Remapped struct { +type CmdVoidInArrayOfPointers struct { binary.Generate - A remapped - B remapped - C remapped + + A Charᵖᵖ + Count int32 } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOut3Remapped +CmdVoidInArrayOfPointers ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOut3Remapped +#### func NewCmdVoidInArrayOfPointers ```go -func NewCmdVoidOut3Remapped( - pA remapped, - pB remapped, - pC remapped, -) *CmdVoidOut3Remapped +func NewCmdVoidInArrayOfPointers(A memory.Pointer, Count int32) *CmdVoidInArrayOfPointers ``` -#### func (*CmdVoidOut3Remapped) API +#### func (*CmdVoidInArrayOfPointers) API ```go -func (c *CmdVoidOut3Remapped) API() gfxapi.API +func (c *CmdVoidInArrayOfPointers) API() gfxapi.API ``` -#### func (*CmdVoidOut3Remapped) Class +#### func (*CmdVoidInArrayOfPointers) AddRead ```go -func (*CmdVoidOut3Remapped) Class() binary.Class +func (a *CmdVoidInArrayOfPointers) AddRead(rng memory.Range, id binary.ID) *CmdVoidInArrayOfPointers ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidInArrayOfPointers pointer is returned so that calls can be +chained. -#### func (*CmdVoidOut3Remapped) Flags +#### func (*CmdVoidInArrayOfPointers) AddWrite ```go -func (c *CmdVoidOut3Remapped) Flags() atom.Flags +func (a *CmdVoidInArrayOfPointers) AddWrite(rng memory.Range, id binary.ID) *CmdVoidInArrayOfPointers ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidInArrayOfPointers pointer is returned so that calls can be +chained. -#### func (*CmdVoidOut3Remapped) Mutate +#### func (*CmdVoidInArrayOfPointers) Class ```go -func (ϟa *CmdVoidOut3Remapped) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidInArrayOfPointers) Class() binary.Class ``` -#### func (*CmdVoidOut3Remapped) Replay +#### func (*CmdVoidInArrayOfPointers) Flags ```go -func (ϟa *CmdVoidOut3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidInArrayOfPointers) Flags() atom.Flags ``` -#### func (*CmdVoidOut3Remapped) String +#### func (*CmdVoidInArrayOfPointers) Mutate ```go -func (c *CmdVoidOut3Remapped) String() string +func (ϟa *CmdVoidInArrayOfPointers) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOut3Remapped) TypeID +#### func (*CmdVoidInArrayOfPointers) Observations ```go -func (c *CmdVoidOut3Remapped) TypeID() atom.TypeID +func (a *CmdVoidInArrayOfPointers) Observations() *atom.Observations ``` -#### type CmdVoidOut3Remapped_Postback +#### func (*CmdVoidInArrayOfPointers) Replay ```go -type CmdVoidOut3Remapped_Postback struct { - A remapped - B remapped - C remapped -} +func (ϟa *CmdVoidInArrayOfPointers) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidInArrayOfPointers) String + +```go +func (a *CmdVoidInArrayOfPointers) String() string +``` -#### func (*CmdVoidOut3Remapped_Postback) Decode +#### func (*CmdVoidInArrayOfPointers) TypeID ```go -func (o *CmdVoidOut3Remapped_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidInArrayOfPointers) TypeID() atom.TypeID ``` -#### type CmdVoidOut3Strings +#### type CmdVoidInArrayOfRemapped ```go -type CmdVoidOut3Strings struct { +type CmdVoidInArrayOfRemapped struct { binary.Generate - A string - B string - C string + + A Remappedᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOut3Strings +CmdVoidInArrayOfRemapped ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOut3Strings +#### func NewCmdVoidInArrayOfRemapped ```go -func NewCmdVoidOut3Strings( - pA string, - pB string, - pC string, -) *CmdVoidOut3Strings +func NewCmdVoidInArrayOfRemapped(A memory.Pointer) *CmdVoidInArrayOfRemapped ``` -#### func (*CmdVoidOut3Strings) API +#### func (*CmdVoidInArrayOfRemapped) API ```go -func (c *CmdVoidOut3Strings) API() gfxapi.API +func (c *CmdVoidInArrayOfRemapped) API() gfxapi.API ``` -#### func (*CmdVoidOut3Strings) Class +#### func (*CmdVoidInArrayOfRemapped) AddRead ```go -func (*CmdVoidOut3Strings) Class() binary.Class +func (a *CmdVoidInArrayOfRemapped) AddRead(rng memory.Range, id binary.ID) *CmdVoidInArrayOfRemapped ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidInArrayOfRemapped pointer is returned so that calls can be +chained. -#### func (*CmdVoidOut3Strings) Flags +#### func (*CmdVoidInArrayOfRemapped) AddWrite ```go -func (c *CmdVoidOut3Strings) Flags() atom.Flags +func (a *CmdVoidInArrayOfRemapped) AddWrite(rng memory.Range, id binary.ID) *CmdVoidInArrayOfRemapped ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidInArrayOfRemapped pointer is returned so that calls can be +chained. -#### func (*CmdVoidOut3Strings) Mutate +#### func (*CmdVoidInArrayOfRemapped) Class ```go -func (ϟa *CmdVoidOut3Strings) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidInArrayOfRemapped) Class() binary.Class ``` -#### func (*CmdVoidOut3Strings) Replay +#### func (*CmdVoidInArrayOfRemapped) Flags ```go -func (ϟa *CmdVoidOut3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidInArrayOfRemapped) Flags() atom.Flags ``` -#### func (*CmdVoidOut3Strings) String +#### func (*CmdVoidInArrayOfRemapped) Mutate ```go -func (c *CmdVoidOut3Strings) String() string +func (ϟa *CmdVoidInArrayOfRemapped) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOut3Strings) TypeID +#### func (*CmdVoidInArrayOfRemapped) Observations ```go -func (c *CmdVoidOut3Strings) TypeID() atom.TypeID +func (a *CmdVoidInArrayOfRemapped) Observations() *atom.Observations ``` -#### type CmdVoidOut3Strings_Postback +#### func (*CmdVoidInArrayOfRemapped) Replay ```go -type CmdVoidOut3Strings_Postback struct { - A string - B string - C string -} +func (ϟa *CmdVoidInArrayOfRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidInArrayOfRemapped) String + +```go +func (a *CmdVoidInArrayOfRemapped) String() string +``` -#### func (*CmdVoidOut3Strings_Postback) Decode +#### func (*CmdVoidInArrayOfRemapped) TypeID ```go -func (o *CmdVoidOut3Strings_Postback) Decode(a_cnt uint64, - b_cnt uint64, - c_cnt uint64, d binary.Decoder) error +func (c *CmdVoidInArrayOfRemapped) TypeID() atom.TypeID ``` #### type CmdVoidOutArrayOfRemapped @@ -1811,7 +3288,8 @@ func (o *CmdVoidOut3Strings_Postback) Decode(a_cnt uint64, ```go type CmdVoidOutArrayOfRemapped struct { binary.Generate - A RemappedArray + + A Remappedᵖ } ``` @@ -1822,9 +3300,7 @@ CmdVoidOutArrayOfRemapped #### func NewCmdVoidOutArrayOfRemapped ```go -func NewCmdVoidOutArrayOfRemapped( - pA RemappedArray, -) *CmdVoidOutArrayOfRemapped +func NewCmdVoidOutArrayOfRemapped(A memory.Pointer) *CmdVoidOutArrayOfRemapped ``` #### func (*CmdVoidOutArrayOfRemapped) API @@ -1833,1069 +3309,1160 @@ func NewCmdVoidOutArrayOfRemapped( func (c *CmdVoidOutArrayOfRemapped) API() gfxapi.API ``` -#### func (*CmdVoidOutArrayOfRemapped) Class +#### func (*CmdVoidOutArrayOfRemapped) AddRead ```go -func (*CmdVoidOutArrayOfRemapped) Class() binary.Class +func (a *CmdVoidOutArrayOfRemapped) AddRead(rng memory.Range, id binary.ID) *CmdVoidOutArrayOfRemapped ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidOutArrayOfRemapped pointer is returned so that calls can be +chained. -#### func (*CmdVoidOutArrayOfRemapped) Flags +#### func (*CmdVoidOutArrayOfRemapped) AddWrite ```go -func (c *CmdVoidOutArrayOfRemapped) Flags() atom.Flags +func (a *CmdVoidOutArrayOfRemapped) AddWrite(rng memory.Range, id binary.ID) *CmdVoidOutArrayOfRemapped ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidOutArrayOfRemapped pointer is returned so that calls can be +chained. -#### func (*CmdVoidOutArrayOfRemapped) Mutate +#### func (*CmdVoidOutArrayOfRemapped) Class ```go -func (ϟa *CmdVoidOutArrayOfRemapped) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidOutArrayOfRemapped) Class() binary.Class ``` -#### func (*CmdVoidOutArrayOfRemapped) Replay +#### func (*CmdVoidOutArrayOfRemapped) Flags ```go -func (ϟa *CmdVoidOutArrayOfRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidOutArrayOfRemapped) Flags() atom.Flags ``` -#### func (*CmdVoidOutArrayOfRemapped) String +#### func (*CmdVoidOutArrayOfRemapped) Mutate ```go -func (c *CmdVoidOutArrayOfRemapped) String() string +func (ϟa *CmdVoidOutArrayOfRemapped) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutArrayOfRemapped) TypeID +#### func (*CmdVoidOutArrayOfRemapped) Observations ```go -func (c *CmdVoidOutArrayOfRemapped) TypeID() atom.TypeID +func (a *CmdVoidOutArrayOfRemapped) Observations() *atom.Observations ``` -#### type CmdVoidOutArrayOfRemapped_Postback +#### func (*CmdVoidOutArrayOfRemapped) Replay ```go -type CmdVoidOutArrayOfRemapped_Postback struct { - A RemappedArray -} +func (ϟa *CmdVoidOutArrayOfRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidOutArrayOfRemapped) String -#### func (*CmdVoidOutArrayOfRemapped_Postback) Decode +```go +func (a *CmdVoidOutArrayOfRemapped) String() string +``` + +#### func (*CmdVoidOutArrayOfRemapped) TypeID ```go -func (o *CmdVoidOutArrayOfRemapped_Postback) Decode(a_cnt uint64, d binary.Decoder) error +func (c *CmdVoidOutArrayOfRemapped) TypeID() atom.TypeID ``` -#### type CmdVoidOutBool +#### type CmdVoidOutArrayOfUnknownRemapped ```go -type CmdVoidOutBool struct { +type CmdVoidOutArrayOfUnknownRemapped struct { binary.Generate - A bool + + A Remappedᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutBool +CmdVoidOutArrayOfUnknownRemapped ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutBool +#### func NewCmdVoidOutArrayOfUnknownRemapped ```go -func NewCmdVoidOutBool( - pA bool, -) *CmdVoidOutBool +func NewCmdVoidOutArrayOfUnknownRemapped(A memory.Pointer) *CmdVoidOutArrayOfUnknownRemapped ``` -#### func (*CmdVoidOutBool) API +#### func (*CmdVoidOutArrayOfUnknownRemapped) API ```go -func (c *CmdVoidOutBool) API() gfxapi.API +func (c *CmdVoidOutArrayOfUnknownRemapped) API() gfxapi.API ``` -#### func (*CmdVoidOutBool) Class +#### func (*CmdVoidOutArrayOfUnknownRemapped) AddRead ```go -func (*CmdVoidOutBool) Class() binary.Class +func (a *CmdVoidOutArrayOfUnknownRemapped) AddRead(rng memory.Range, id binary.ID) *CmdVoidOutArrayOfUnknownRemapped ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidOutArrayOfUnknownRemapped pointer is returned so that calls +can be chained. -#### func (*CmdVoidOutBool) Flags +#### func (*CmdVoidOutArrayOfUnknownRemapped) AddWrite ```go -func (c *CmdVoidOutBool) Flags() atom.Flags +func (a *CmdVoidOutArrayOfUnknownRemapped) AddWrite(rng memory.Range, id binary.ID) *CmdVoidOutArrayOfUnknownRemapped ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidOutArrayOfUnknownRemapped pointer is returned so that calls +can be chained. -#### func (*CmdVoidOutBool) Mutate +#### func (*CmdVoidOutArrayOfUnknownRemapped) Class ```go -func (ϟa *CmdVoidOutBool) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidOutArrayOfUnknownRemapped) Class() binary.Class ``` -#### func (*CmdVoidOutBool) Replay +#### func (*CmdVoidOutArrayOfUnknownRemapped) Flags ```go -func (ϟa *CmdVoidOutBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidOutArrayOfUnknownRemapped) Flags() atom.Flags ``` -#### func (*CmdVoidOutBool) String +#### func (*CmdVoidOutArrayOfUnknownRemapped) Mutate ```go -func (c *CmdVoidOutBool) String() string +func (ϟa *CmdVoidOutArrayOfUnknownRemapped) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutBool) TypeID +#### func (*CmdVoidOutArrayOfUnknownRemapped) Observations ```go -func (c *CmdVoidOutBool) TypeID() atom.TypeID +func (a *CmdVoidOutArrayOfUnknownRemapped) Observations() *atom.Observations ``` -#### type CmdVoidOutBool_Postback +#### func (*CmdVoidOutArrayOfUnknownRemapped) Replay ```go -type CmdVoidOutBool_Postback struct { - A bool -} +func (ϟa *CmdVoidOutArrayOfUnknownRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidOutArrayOfUnknownRemapped) String -#### func (*CmdVoidOutBool_Postback) Decode +```go +func (a *CmdVoidOutArrayOfUnknownRemapped) String() string +``` + +#### func (*CmdVoidOutArrayOfUnknownRemapped) TypeID ```go -func (o *CmdVoidOutBool_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidOutArrayOfUnknownRemapped) TypeID() atom.TypeID ``` -#### type CmdVoidOutF32 +#### type CmdVoidReadBool ```go -type CmdVoidOutF32 struct { +type CmdVoidReadBool struct { binary.Generate - A float32 + + A Boolᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutF32 +CmdVoidReadBool ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutF32 +#### func NewCmdVoidReadBool ```go -func NewCmdVoidOutF32( - pA float32, -) *CmdVoidOutF32 +func NewCmdVoidReadBool(A memory.Pointer) *CmdVoidReadBool ``` -#### func (*CmdVoidOutF32) API +#### func (*CmdVoidReadBool) API ```go -func (c *CmdVoidOutF32) API() gfxapi.API +func (c *CmdVoidReadBool) API() gfxapi.API ``` -#### func (*CmdVoidOutF32) Class +#### func (*CmdVoidReadBool) AddRead ```go -func (*CmdVoidOutF32) Class() binary.Class +func (a *CmdVoidReadBool) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadBool ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadBool pointer is returned so that calls can be chained. -#### func (*CmdVoidOutF32) Flags +#### func (*CmdVoidReadBool) AddWrite ```go -func (c *CmdVoidOutF32) Flags() atom.Flags +func (a *CmdVoidReadBool) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadBool ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadBool pointer is returned so that calls can be chained. -#### func (*CmdVoidOutF32) Mutate +#### func (*CmdVoidReadBool) Class ```go -func (ϟa *CmdVoidOutF32) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadBool) Class() binary.Class ``` -#### func (*CmdVoidOutF32) Replay +#### func (*CmdVoidReadBool) Flags ```go -func (ϟa *CmdVoidOutF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadBool) Flags() atom.Flags ``` -#### func (*CmdVoidOutF32) String +#### func (*CmdVoidReadBool) Mutate ```go -func (c *CmdVoidOutF32) String() string +func (ϟa *CmdVoidReadBool) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutF32) TypeID +#### func (*CmdVoidReadBool) Observations ```go -func (c *CmdVoidOutF32) TypeID() atom.TypeID +func (a *CmdVoidReadBool) Observations() *atom.Observations ``` -#### type CmdVoidOutF32_Postback +#### func (*CmdVoidReadBool) Replay ```go -type CmdVoidOutF32_Postback struct { - A float32 -} +func (ϟa *CmdVoidReadBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadBool) String -#### func (*CmdVoidOutF32_Postback) Decode +```go +func (a *CmdVoidReadBool) String() string +``` + +#### func (*CmdVoidReadBool) TypeID ```go -func (o *CmdVoidOutF32_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadBool) TypeID() atom.TypeID ``` -#### type CmdVoidOutF64 +#### type CmdVoidReadF32 ```go -type CmdVoidOutF64 struct { +type CmdVoidReadF32 struct { binary.Generate - A float64 + + A F32ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutF64 +CmdVoidReadF32 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutF64 +#### func NewCmdVoidReadF32 ```go -func NewCmdVoidOutF64( - pA float64, -) *CmdVoidOutF64 +func NewCmdVoidReadF32(A memory.Pointer) *CmdVoidReadF32 ``` -#### func (*CmdVoidOutF64) API +#### func (*CmdVoidReadF32) API ```go -func (c *CmdVoidOutF64) API() gfxapi.API +func (c *CmdVoidReadF32) API() gfxapi.API ``` -#### func (*CmdVoidOutF64) Class +#### func (*CmdVoidReadF32) AddRead ```go -func (*CmdVoidOutF64) Class() binary.Class +func (a *CmdVoidReadF32) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadF32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadF32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutF64) Flags +#### func (*CmdVoidReadF32) AddWrite ```go -func (c *CmdVoidOutF64) Flags() atom.Flags +func (a *CmdVoidReadF32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadF32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadF32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutF64) Mutate +#### func (*CmdVoidReadF32) Class ```go -func (ϟa *CmdVoidOutF64) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadF32) Class() binary.Class ``` -#### func (*CmdVoidOutF64) Replay +#### func (*CmdVoidReadF32) Flags ```go -func (ϟa *CmdVoidOutF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadF32) Flags() atom.Flags ``` -#### func (*CmdVoidOutF64) String +#### func (*CmdVoidReadF32) Mutate ```go -func (c *CmdVoidOutF64) String() string +func (ϟa *CmdVoidReadF32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutF64) TypeID +#### func (*CmdVoidReadF32) Observations ```go -func (c *CmdVoidOutF64) TypeID() atom.TypeID +func (a *CmdVoidReadF32) Observations() *atom.Observations ``` -#### type CmdVoidOutF64_Postback +#### func (*CmdVoidReadF32) Replay ```go -type CmdVoidOutF64_Postback struct { - A float64 -} +func (ϟa *CmdVoidReadF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadF32) String -#### func (*CmdVoidOutF64_Postback) Decode +```go +func (a *CmdVoidReadF32) String() string +``` + +#### func (*CmdVoidReadF32) TypeID ```go -func (o *CmdVoidOutF64_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadF32) TypeID() atom.TypeID ``` -#### type CmdVoidOutFixedSizeBuffer +#### type CmdVoidReadF64 ```go -type CmdVoidOutFixedSizeBuffer struct { +type CmdVoidReadF64 struct { binary.Generate - A memory.Pointer + + A F64ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutFixedSizeBuffer +CmdVoidReadF64 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutFixedSizeBuffer +#### func NewCmdVoidReadF64 ```go -func NewCmdVoidOutFixedSizeBuffer( - pA memory.Pointer, -) *CmdVoidOutFixedSizeBuffer +func NewCmdVoidReadF64(A memory.Pointer) *CmdVoidReadF64 ``` -#### func (*CmdVoidOutFixedSizeBuffer) API +#### func (*CmdVoidReadF64) API ```go -func (c *CmdVoidOutFixedSizeBuffer) API() gfxapi.API +func (c *CmdVoidReadF64) API() gfxapi.API ``` -#### func (*CmdVoidOutFixedSizeBuffer) Class +#### func (*CmdVoidReadF64) AddRead ```go -func (*CmdVoidOutFixedSizeBuffer) Class() binary.Class +func (a *CmdVoidReadF64) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadF64 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadF64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutFixedSizeBuffer) Flags +#### func (*CmdVoidReadF64) AddWrite ```go -func (c *CmdVoidOutFixedSizeBuffer) Flags() atom.Flags +func (a *CmdVoidReadF64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadF64 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadF64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutFixedSizeBuffer) Mutate +#### func (*CmdVoidReadF64) Class ```go -func (ϟa *CmdVoidOutFixedSizeBuffer) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadF64) Class() binary.Class ``` -#### func (*CmdVoidOutFixedSizeBuffer) Replay +#### func (*CmdVoidReadF64) Flags ```go -func (ϟa *CmdVoidOutFixedSizeBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadF64) Flags() atom.Flags ``` -#### func (*CmdVoidOutFixedSizeBuffer) String +#### func (*CmdVoidReadF64) Mutate ```go -func (c *CmdVoidOutFixedSizeBuffer) String() string +func (ϟa *CmdVoidReadF64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutFixedSizeBuffer) TypeID +#### func (*CmdVoidReadF64) Observations ```go -func (c *CmdVoidOutFixedSizeBuffer) TypeID() atom.TypeID +func (a *CmdVoidReadF64) Observations() *atom.Observations ``` -#### type CmdVoidOutFixedSizeBuffer_Postback +#### func (*CmdVoidReadF64) Replay ```go -type CmdVoidOutFixedSizeBuffer_Postback struct { - A []byte -} +func (ϟa *CmdVoidReadF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadF64) String -#### func (*CmdVoidOutFixedSizeBuffer_Postback) Decode +```go +func (a *CmdVoidReadF64) String() string +``` + +#### func (*CmdVoidReadF64) TypeID ```go -func (o *CmdVoidOutFixedSizeBuffer_Postback) Decode(a_cnt uint64, d binary.Decoder) error +func (c *CmdVoidReadF64) TypeID() atom.TypeID ``` -#### type CmdVoidOutS16 +#### type CmdVoidReadPtrs ```go -type CmdVoidOutS16 struct { +type CmdVoidReadPtrs struct { binary.Generate - A int16 + + A F32ᵖ + B U16ᵖ + C Boolᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutS16 +CmdVoidReadPtrs ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutS16 +#### func NewCmdVoidReadPtrs ```go -func NewCmdVoidOutS16( - pA int16, -) *CmdVoidOutS16 +func NewCmdVoidReadPtrs(A memory.Pointer, B memory.Pointer, C memory.Pointer) *CmdVoidReadPtrs ``` -#### func (*CmdVoidOutS16) API +#### func (*CmdVoidReadPtrs) API ```go -func (c *CmdVoidOutS16) API() gfxapi.API +func (c *CmdVoidReadPtrs) API() gfxapi.API ``` -#### func (*CmdVoidOutS16) Class +#### func (*CmdVoidReadPtrs) AddRead ```go -func (*CmdVoidOutS16) Class() binary.Class +func (a *CmdVoidReadPtrs) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadPtrs ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadPtrs pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS16) Flags +#### func (*CmdVoidReadPtrs) AddWrite ```go -func (c *CmdVoidOutS16) Flags() atom.Flags +func (a *CmdVoidReadPtrs) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadPtrs ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadPtrs pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS16) Mutate +#### func (*CmdVoidReadPtrs) Class ```go -func (ϟa *CmdVoidOutS16) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadPtrs) Class() binary.Class ``` -#### func (*CmdVoidOutS16) Replay +#### func (*CmdVoidReadPtrs) Flags ```go -func (ϟa *CmdVoidOutS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadPtrs) Flags() atom.Flags ``` -#### func (*CmdVoidOutS16) String +#### func (*CmdVoidReadPtrs) Mutate ```go -func (c *CmdVoidOutS16) String() string +func (ϟa *CmdVoidReadPtrs) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutS16) TypeID +#### func (*CmdVoidReadPtrs) Observations ```go -func (c *CmdVoidOutS16) TypeID() atom.TypeID +func (a *CmdVoidReadPtrs) Observations() *atom.Observations ``` -#### type CmdVoidOutS16_Postback +#### func (*CmdVoidReadPtrs) Replay ```go -type CmdVoidOutS16_Postback struct { - A int16 -} +func (ϟa *CmdVoidReadPtrs) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadPtrs) String -#### func (*CmdVoidOutS16_Postback) Decode +```go +func (a *CmdVoidReadPtrs) String() string +``` + +#### func (*CmdVoidReadPtrs) TypeID ```go -func (o *CmdVoidOutS16_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadPtrs) TypeID() atom.TypeID ``` -#### type CmdVoidOutS32 +#### type CmdVoidReadS16 ```go -type CmdVoidOutS32 struct { +type CmdVoidReadS16 struct { binary.Generate - A int32 + + A S16ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutS32 +CmdVoidReadS16 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutS32 +#### func NewCmdVoidReadS16 ```go -func NewCmdVoidOutS32( - pA int32, -) *CmdVoidOutS32 +func NewCmdVoidReadS16(A memory.Pointer) *CmdVoidReadS16 ``` -#### func (*CmdVoidOutS32) API +#### func (*CmdVoidReadS16) API ```go -func (c *CmdVoidOutS32) API() gfxapi.API +func (c *CmdVoidReadS16) API() gfxapi.API ``` -#### func (*CmdVoidOutS32) Class +#### func (*CmdVoidReadS16) AddRead ```go -func (*CmdVoidOutS32) Class() binary.Class +func (a *CmdVoidReadS16) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadS16 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadS16 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS32) Flags +#### func (*CmdVoidReadS16) AddWrite ```go -func (c *CmdVoidOutS32) Flags() atom.Flags +func (a *CmdVoidReadS16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadS16 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadS16 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS32) Mutate +#### func (*CmdVoidReadS16) Class ```go -func (ϟa *CmdVoidOutS32) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadS16) Class() binary.Class ``` -#### func (*CmdVoidOutS32) Replay +#### func (*CmdVoidReadS16) Flags ```go -func (ϟa *CmdVoidOutS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadS16) Flags() atom.Flags ``` -#### func (*CmdVoidOutS32) String +#### func (*CmdVoidReadS16) Mutate ```go -func (c *CmdVoidOutS32) String() string +func (ϟa *CmdVoidReadS16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutS32) TypeID +#### func (*CmdVoidReadS16) Observations ```go -func (c *CmdVoidOutS32) TypeID() atom.TypeID +func (a *CmdVoidReadS16) Observations() *atom.Observations ``` -#### type CmdVoidOutS32_Postback +#### func (*CmdVoidReadS16) Replay ```go -type CmdVoidOutS32_Postback struct { - A int32 -} +func (ϟa *CmdVoidReadS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadS16) String -#### func (*CmdVoidOutS32_Postback) Decode +```go +func (a *CmdVoidReadS16) String() string +``` + +#### func (*CmdVoidReadS16) TypeID ```go -func (o *CmdVoidOutS32_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadS16) TypeID() atom.TypeID ``` -#### type CmdVoidOutS64 +#### type CmdVoidReadS32 ```go -type CmdVoidOutS64 struct { +type CmdVoidReadS32 struct { binary.Generate - A int64 + + A S32ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutS64 +CmdVoidReadS32 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutS64 +#### func NewCmdVoidReadS32 ```go -func NewCmdVoidOutS64( - pA int64, -) *CmdVoidOutS64 +func NewCmdVoidReadS32(A memory.Pointer) *CmdVoidReadS32 ``` -#### func (*CmdVoidOutS64) API +#### func (*CmdVoidReadS32) API ```go -func (c *CmdVoidOutS64) API() gfxapi.API +func (c *CmdVoidReadS32) API() gfxapi.API ``` -#### func (*CmdVoidOutS64) Class +#### func (*CmdVoidReadS32) AddRead ```go -func (*CmdVoidOutS64) Class() binary.Class +func (a *CmdVoidReadS32) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadS32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadS32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS64) Flags +#### func (*CmdVoidReadS32) AddWrite ```go -func (c *CmdVoidOutS64) Flags() atom.Flags +func (a *CmdVoidReadS32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadS32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadS32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS64) Mutate +#### func (*CmdVoidReadS32) Class ```go -func (ϟa *CmdVoidOutS64) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadS32) Class() binary.Class ``` -#### func (*CmdVoidOutS64) Replay +#### func (*CmdVoidReadS32) Flags ```go -func (ϟa *CmdVoidOutS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadS32) Flags() atom.Flags ``` -#### func (*CmdVoidOutS64) String +#### func (*CmdVoidReadS32) Mutate ```go -func (c *CmdVoidOutS64) String() string +func (ϟa *CmdVoidReadS32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutS64) TypeID +#### func (*CmdVoidReadS32) Observations ```go -func (c *CmdVoidOutS64) TypeID() atom.TypeID +func (a *CmdVoidReadS32) Observations() *atom.Observations ``` -#### type CmdVoidOutS64_Postback +#### func (*CmdVoidReadS32) Replay ```go -type CmdVoidOutS64_Postback struct { - A int64 -} +func (ϟa *CmdVoidReadS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadS32) String -#### func (*CmdVoidOutS64_Postback) Decode +```go +func (a *CmdVoidReadS32) String() string +``` + +#### func (*CmdVoidReadS32) TypeID ```go -func (o *CmdVoidOutS64_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadS32) TypeID() atom.TypeID ``` -#### type CmdVoidOutS8 +#### type CmdVoidReadS64 ```go -type CmdVoidOutS8 struct { +type CmdVoidReadS64 struct { binary.Generate - A int8 + + A S64ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutS8 +CmdVoidReadS64 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutS8 +#### func NewCmdVoidReadS64 ```go -func NewCmdVoidOutS8( - pA int8, -) *CmdVoidOutS8 +func NewCmdVoidReadS64(A memory.Pointer) *CmdVoidReadS64 ``` -#### func (*CmdVoidOutS8) API +#### func (*CmdVoidReadS64) API ```go -func (c *CmdVoidOutS8) API() gfxapi.API +func (c *CmdVoidReadS64) API() gfxapi.API ``` -#### func (*CmdVoidOutS8) Class +#### func (*CmdVoidReadS64) AddRead ```go -func (*CmdVoidOutS8) Class() binary.Class +func (a *CmdVoidReadS64) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadS64 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadS64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS8) Flags +#### func (*CmdVoidReadS64) AddWrite ```go -func (c *CmdVoidOutS8) Flags() atom.Flags +func (a *CmdVoidReadS64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadS64 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadS64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutS8) Mutate +#### func (*CmdVoidReadS64) Class ```go -func (ϟa *CmdVoidOutS8) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadS64) Class() binary.Class ``` -#### func (*CmdVoidOutS8) Replay +#### func (*CmdVoidReadS64) Flags ```go -func (ϟa *CmdVoidOutS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadS64) Flags() atom.Flags ``` -#### func (*CmdVoidOutS8) String +#### func (*CmdVoidReadS64) Mutate ```go -func (c *CmdVoidOutS8) String() string +func (ϟa *CmdVoidReadS64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutS8) TypeID +#### func (*CmdVoidReadS64) Observations ```go -func (c *CmdVoidOutS8) TypeID() atom.TypeID +func (a *CmdVoidReadS64) Observations() *atom.Observations ``` -#### type CmdVoidOutS8_Postback +#### func (*CmdVoidReadS64) Replay ```go -type CmdVoidOutS8_Postback struct { - A int8 -} +func (ϟa *CmdVoidReadS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadS64) String -#### func (*CmdVoidOutS8_Postback) Decode +```go +func (a *CmdVoidReadS64) String() string +``` + +#### func (*CmdVoidReadS64) TypeID ```go -func (o *CmdVoidOutS8_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadS64) TypeID() atom.TypeID ``` -#### type CmdVoidOutString +#### type CmdVoidReadS8 ```go -type CmdVoidOutString struct { +type CmdVoidReadS8 struct { binary.Generate - A string + + A S8ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutString +CmdVoidReadS8 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutString +#### func NewCmdVoidReadS8 ```go -func NewCmdVoidOutString( - pA string, -) *CmdVoidOutString +func NewCmdVoidReadS8(A memory.Pointer) *CmdVoidReadS8 ``` -#### func (*CmdVoidOutString) API +#### func (*CmdVoidReadS8) API ```go -func (c *CmdVoidOutString) API() gfxapi.API +func (c *CmdVoidReadS8) API() gfxapi.API ``` -#### func (*CmdVoidOutString) Class +#### func (*CmdVoidReadS8) AddRead ```go -func (*CmdVoidOutString) Class() binary.Class +func (a *CmdVoidReadS8) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadS8 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadS8 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutString) Flags +#### func (*CmdVoidReadS8) AddWrite ```go -func (c *CmdVoidOutString) Flags() atom.Flags +func (a *CmdVoidReadS8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadS8 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadS8 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutString) Mutate +#### func (*CmdVoidReadS8) Class ```go -func (ϟa *CmdVoidOutString) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadS8) Class() binary.Class ``` -#### func (*CmdVoidOutString) Replay +#### func (*CmdVoidReadS8) Flags ```go -func (ϟa *CmdVoidOutString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadS8) Flags() atom.Flags ``` -#### func (*CmdVoidOutString) String +#### func (*CmdVoidReadS8) Mutate ```go -func (c *CmdVoidOutString) String() string +func (ϟa *CmdVoidReadS8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutString) TypeID +#### func (*CmdVoidReadS8) Observations ```go -func (c *CmdVoidOutString) TypeID() atom.TypeID +func (a *CmdVoidReadS8) Observations() *atom.Observations ``` -#### type CmdVoidOutString_Postback +#### func (*CmdVoidReadS8) Replay ```go -type CmdVoidOutString_Postback struct { - A string -} +func (ϟa *CmdVoidReadS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadS8) String + +```go +func (a *CmdVoidReadS8) String() string +``` -#### func (*CmdVoidOutString_Postback) Decode +#### func (*CmdVoidReadS8) TypeID ```go -func (o *CmdVoidOutString_Postback) Decode(a_cnt uint64, d binary.Decoder) error +func (c *CmdVoidReadS8) TypeID() atom.TypeID ``` -#### type CmdVoidOutU16 +#### type CmdVoidReadU16 ```go -type CmdVoidOutU16 struct { +type CmdVoidReadU16 struct { binary.Generate - A uint16 + + A U16ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutU16 +CmdVoidReadU16 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutU16 +#### func NewCmdVoidReadU16 ```go -func NewCmdVoidOutU16( - pA uint16, -) *CmdVoidOutU16 +func NewCmdVoidReadU16(A memory.Pointer) *CmdVoidReadU16 ``` -#### func (*CmdVoidOutU16) API +#### func (*CmdVoidReadU16) API ```go -func (c *CmdVoidOutU16) API() gfxapi.API +func (c *CmdVoidReadU16) API() gfxapi.API ``` -#### func (*CmdVoidOutU16) Class +#### func (*CmdVoidReadU16) AddRead ```go -func (*CmdVoidOutU16) Class() binary.Class +func (a *CmdVoidReadU16) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadU16 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadU16 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU16) Flags +#### func (*CmdVoidReadU16) AddWrite ```go -func (c *CmdVoidOutU16) Flags() atom.Flags +func (a *CmdVoidReadU16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadU16 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadU16 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU16) Mutate +#### func (*CmdVoidReadU16) Class ```go -func (ϟa *CmdVoidOutU16) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadU16) Class() binary.Class ``` -#### func (*CmdVoidOutU16) Replay +#### func (*CmdVoidReadU16) Flags ```go -func (ϟa *CmdVoidOutU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadU16) Flags() atom.Flags ``` -#### func (*CmdVoidOutU16) String +#### func (*CmdVoidReadU16) Mutate ```go -func (c *CmdVoidOutU16) String() string +func (ϟa *CmdVoidReadU16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutU16) TypeID +#### func (*CmdVoidReadU16) Observations ```go -func (c *CmdVoidOutU16) TypeID() atom.TypeID +func (a *CmdVoidReadU16) Observations() *atom.Observations ``` -#### type CmdVoidOutU16_Postback +#### func (*CmdVoidReadU16) Replay ```go -type CmdVoidOutU16_Postback struct { - A uint16 -} +func (ϟa *CmdVoidReadU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadU16) String + +```go +func (a *CmdVoidReadU16) String() string +``` -#### func (*CmdVoidOutU16_Postback) Decode +#### func (*CmdVoidReadU16) TypeID ```go -func (o *CmdVoidOutU16_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadU16) TypeID() atom.TypeID ``` -#### type CmdVoidOutU32 +#### type CmdVoidReadU32 ```go -type CmdVoidOutU32 struct { +type CmdVoidReadU32 struct { binary.Generate - A uint32 + + A U32ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutU32 +CmdVoidReadU32 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutU32 +#### func NewCmdVoidReadU32 ```go -func NewCmdVoidOutU32( - pA uint32, -) *CmdVoidOutU32 +func NewCmdVoidReadU32(A memory.Pointer) *CmdVoidReadU32 ``` -#### func (*CmdVoidOutU32) API +#### func (*CmdVoidReadU32) API ```go -func (c *CmdVoidOutU32) API() gfxapi.API +func (c *CmdVoidReadU32) API() gfxapi.API ``` -#### func (*CmdVoidOutU32) Class +#### func (*CmdVoidReadU32) AddRead ```go -func (*CmdVoidOutU32) Class() binary.Class +func (a *CmdVoidReadU32) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadU32 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadU32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU32) Flags +#### func (*CmdVoidReadU32) AddWrite ```go -func (c *CmdVoidOutU32) Flags() atom.Flags +func (a *CmdVoidReadU32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadU32 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadU32 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU32) Mutate +#### func (*CmdVoidReadU32) Class ```go -func (ϟa *CmdVoidOutU32) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadU32) Class() binary.Class ``` -#### func (*CmdVoidOutU32) Replay +#### func (*CmdVoidReadU32) Flags ```go -func (ϟa *CmdVoidOutU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadU32) Flags() atom.Flags ``` -#### func (*CmdVoidOutU32) String +#### func (*CmdVoidReadU32) Mutate ```go -func (c *CmdVoidOutU32) String() string +func (ϟa *CmdVoidReadU32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutU32) TypeID +#### func (*CmdVoidReadU32) Observations ```go -func (c *CmdVoidOutU32) TypeID() atom.TypeID +func (a *CmdVoidReadU32) Observations() *atom.Observations ``` -#### type CmdVoidOutU32_Postback +#### func (*CmdVoidReadU32) Replay ```go -type CmdVoidOutU32_Postback struct { - A uint32 -} +func (ϟa *CmdVoidReadU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadU32) String -#### func (*CmdVoidOutU32_Postback) Decode +```go +func (a *CmdVoidReadU32) String() string +``` + +#### func (*CmdVoidReadU32) TypeID ```go -func (o *CmdVoidOutU32_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadU32) TypeID() atom.TypeID ``` -#### type CmdVoidOutU64 +#### type CmdVoidReadU64 ```go -type CmdVoidOutU64 struct { +type CmdVoidReadU64 struct { binary.Generate - A uint64 + + A U64ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutU64 +CmdVoidReadU64 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutU64 +#### func NewCmdVoidReadU64 ```go -func NewCmdVoidOutU64( - pA uint64, -) *CmdVoidOutU64 +func NewCmdVoidReadU64(A memory.Pointer) *CmdVoidReadU64 ``` -#### func (*CmdVoidOutU64) API +#### func (*CmdVoidReadU64) API ```go -func (c *CmdVoidOutU64) API() gfxapi.API +func (c *CmdVoidReadU64) API() gfxapi.API ``` -#### func (*CmdVoidOutU64) Class +#### func (*CmdVoidReadU64) AddRead ```go -func (*CmdVoidOutU64) Class() binary.Class +func (a *CmdVoidReadU64) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadU64 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadU64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU64) Flags +#### func (*CmdVoidReadU64) AddWrite ```go -func (c *CmdVoidOutU64) Flags() atom.Flags +func (a *CmdVoidReadU64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadU64 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadU64 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU64) Mutate +#### func (*CmdVoidReadU64) Class ```go -func (ϟa *CmdVoidOutU64) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadU64) Class() binary.Class ``` -#### func (*CmdVoidOutU64) Replay +#### func (*CmdVoidReadU64) Flags ```go -func (ϟa *CmdVoidOutU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadU64) Flags() atom.Flags ``` -#### func (*CmdVoidOutU64) String +#### func (*CmdVoidReadU64) Mutate ```go -func (c *CmdVoidOutU64) String() string +func (ϟa *CmdVoidReadU64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutU64) TypeID +#### func (*CmdVoidReadU64) Observations ```go -func (c *CmdVoidOutU64) TypeID() atom.TypeID +func (a *CmdVoidReadU64) Observations() *atom.Observations ``` -#### type CmdVoidOutU64_Postback +#### func (*CmdVoidReadU64) Replay ```go -type CmdVoidOutU64_Postback struct { - A uint64 -} +func (ϟa *CmdVoidReadU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadU64) String + +```go +func (a *CmdVoidReadU64) String() string +``` -#### func (*CmdVoidOutU64_Postback) Decode +#### func (*CmdVoidReadU64) TypeID ```go -func (o *CmdVoidOutU64_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadU64) TypeID() atom.TypeID ``` -#### type CmdVoidOutU8 +#### type CmdVoidReadU8 ```go -type CmdVoidOutU8 struct { +type CmdVoidReadU8 struct { binary.Generate - A uint8 + + A U8ᵖ } ``` ////////////////////////////////////////////////////////////////////////////// -CmdVoidOutU8 +CmdVoidReadU8 ////////////////////////////////////////////////////////////////////////////// -#### func NewCmdVoidOutU8 +#### func NewCmdVoidReadU8 ```go -func NewCmdVoidOutU8( - pA uint8, -) *CmdVoidOutU8 +func NewCmdVoidReadU8(A memory.Pointer) *CmdVoidReadU8 ``` -#### func (*CmdVoidOutU8) API +#### func (*CmdVoidReadU8) API ```go -func (c *CmdVoidOutU8) API() gfxapi.API +func (c *CmdVoidReadU8) API() gfxapi.API ``` -#### func (*CmdVoidOutU8) Class +#### func (*CmdVoidReadU8) AddRead ```go -func (*CmdVoidOutU8) Class() binary.Class +func (a *CmdVoidReadU8) AddRead(rng memory.Range, id binary.ID) *CmdVoidReadU8 ``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidReadU8 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU8) Flags +#### func (*CmdVoidReadU8) AddWrite ```go -func (c *CmdVoidOutU8) Flags() atom.Flags +func (a *CmdVoidReadU8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidReadU8 ``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidReadU8 pointer is returned so that calls can be chained. -#### func (*CmdVoidOutU8) Mutate +#### func (*CmdVoidReadU8) Class ```go -func (ϟa *CmdVoidOutU8) Mutate(ϟs *gfxapi.State) error +func (*CmdVoidReadU8) Class() binary.Class ``` -#### func (*CmdVoidOutU8) Replay +#### func (*CmdVoidReadU8) Flags ```go -func (ϟa *CmdVoidOutU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (c *CmdVoidReadU8) Flags() atom.Flags ``` -#### func (*CmdVoidOutU8) String +#### func (*CmdVoidReadU8) Mutate ```go -func (c *CmdVoidOutU8) String() string +func (ϟa *CmdVoidReadU8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (*CmdVoidOutU8) TypeID +#### func (*CmdVoidReadU8) Observations ```go -func (c *CmdVoidOutU8) TypeID() atom.TypeID +func (a *CmdVoidReadU8) Observations() *atom.Observations ``` -#### type CmdVoidOutU8_Postback +#### func (*CmdVoidReadU8) Replay ```go -type CmdVoidOutU8_Postback struct { - A uint8 -} +func (ϟa *CmdVoidReadU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` +#### func (*CmdVoidReadU8) String -#### func (*CmdVoidOutU8_Postback) Decode +```go +func (a *CmdVoidReadU8) String() string +``` + +#### func (*CmdVoidReadU8) TypeID ```go -func (o *CmdVoidOutU8_Postback) Decode(d binary.Decoder) error +func (c *CmdVoidReadU8) TypeID() atom.TypeID ``` #### type CmdVoidS16 @@ -2903,6 +4470,7 @@ func (o *CmdVoidOutU8_Postback) Decode(d binary.Decoder) error ```go type CmdVoidS16 struct { binary.Generate + A int16 } ``` @@ -2914,9 +4482,7 @@ CmdVoidS16 #### func NewCmdVoidS16 ```go -func NewCmdVoidS16( - pA int16, -) *CmdVoidS16 +func NewCmdVoidS16(A int16) *CmdVoidS16 ``` #### func (*CmdVoidS16) API @@ -2925,6 +4491,22 @@ func NewCmdVoidS16( func (c *CmdVoidS16) API() gfxapi.API ``` +#### func (*CmdVoidS16) AddRead + +```go +func (a *CmdVoidS16) AddRead(rng memory.Range, id binary.ID) *CmdVoidS16 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidS16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidS16) AddWrite + +```go +func (a *CmdVoidS16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidS16 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidS16 pointer is returned so that calls can be chained. + #### func (*CmdVoidS16) Class ```go @@ -2940,19 +4522,25 @@ func (c *CmdVoidS16) Flags() atom.Flags #### func (*CmdVoidS16) Mutate ```go -func (ϟa *CmdVoidS16) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidS16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidS16) Observations + +```go +func (a *CmdVoidS16) Observations() *atom.Observations ``` #### func (*CmdVoidS16) Replay ```go -func (ϟa *CmdVoidS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidS16) String ```go -func (c *CmdVoidS16) String() string +func (a *CmdVoidS16) String() string ``` #### func (*CmdVoidS16) TypeID @@ -2966,6 +4554,7 @@ func (c *CmdVoidS16) TypeID() atom.TypeID ```go type CmdVoidS32 struct { binary.Generate + A int32 } ``` @@ -2977,9 +4566,7 @@ CmdVoidS32 #### func NewCmdVoidS32 ```go -func NewCmdVoidS32( - pA int32, -) *CmdVoidS32 +func NewCmdVoidS32(A int32) *CmdVoidS32 ``` #### func (*CmdVoidS32) API @@ -2988,6 +4575,22 @@ func NewCmdVoidS32( func (c *CmdVoidS32) API() gfxapi.API ``` +#### func (*CmdVoidS32) AddRead + +```go +func (a *CmdVoidS32) AddRead(rng memory.Range, id binary.ID) *CmdVoidS32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidS32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidS32) AddWrite + +```go +func (a *CmdVoidS32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidS32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidS32 pointer is returned so that calls can be chained. + #### func (*CmdVoidS32) Class ```go @@ -3003,19 +4606,25 @@ func (c *CmdVoidS32) Flags() atom.Flags #### func (*CmdVoidS32) Mutate ```go -func (ϟa *CmdVoidS32) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidS32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidS32) Observations + +```go +func (a *CmdVoidS32) Observations() *atom.Observations ``` #### func (*CmdVoidS32) Replay ```go -func (ϟa *CmdVoidS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidS32) String ```go -func (c *CmdVoidS32) String() string +func (a *CmdVoidS32) String() string ``` #### func (*CmdVoidS32) TypeID @@ -3029,6 +4638,7 @@ func (c *CmdVoidS32) TypeID() atom.TypeID ```go type CmdVoidS64 struct { binary.Generate + A int64 } ``` @@ -3040,9 +4650,7 @@ CmdVoidS64 #### func NewCmdVoidS64 ```go -func NewCmdVoidS64( - pA int64, -) *CmdVoidS64 +func NewCmdVoidS64(A int64) *CmdVoidS64 ``` #### func (*CmdVoidS64) API @@ -3051,6 +4659,22 @@ func NewCmdVoidS64( func (c *CmdVoidS64) API() gfxapi.API ``` +#### func (*CmdVoidS64) AddRead + +```go +func (a *CmdVoidS64) AddRead(rng memory.Range, id binary.ID) *CmdVoidS64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidS64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidS64) AddWrite + +```go +func (a *CmdVoidS64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidS64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidS64 pointer is returned so that calls can be chained. + #### func (*CmdVoidS64) Class ```go @@ -3066,19 +4690,25 @@ func (c *CmdVoidS64) Flags() atom.Flags #### func (*CmdVoidS64) Mutate ```go -func (ϟa *CmdVoidS64) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidS64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidS64) Observations + +```go +func (a *CmdVoidS64) Observations() *atom.Observations ``` #### func (*CmdVoidS64) Replay ```go -func (ϟa *CmdVoidS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidS64) String ```go -func (c *CmdVoidS64) String() string +func (a *CmdVoidS64) String() string ``` #### func (*CmdVoidS64) TypeID @@ -3092,6 +4722,7 @@ func (c *CmdVoidS64) TypeID() atom.TypeID ```go type CmdVoidS8 struct { binary.Generate + A int8 } ``` @@ -3103,9 +4734,7 @@ CmdVoidS8 #### func NewCmdVoidS8 ```go -func NewCmdVoidS8( - pA int8, -) *CmdVoidS8 +func NewCmdVoidS8(A int8) *CmdVoidS8 ``` #### func (*CmdVoidS8) API @@ -3114,6 +4743,22 @@ func NewCmdVoidS8( func (c *CmdVoidS8) API() gfxapi.API ``` +#### func (*CmdVoidS8) AddRead + +```go +func (a *CmdVoidS8) AddRead(rng memory.Range, id binary.ID) *CmdVoidS8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidS8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidS8) AddWrite + +```go +func (a *CmdVoidS8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidS8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidS8 pointer is returned so that calls can be chained. + #### func (*CmdVoidS8) Class ```go @@ -3129,19 +4774,25 @@ func (c *CmdVoidS8) Flags() atom.Flags #### func (*CmdVoidS8) Mutate ```go -func (ϟa *CmdVoidS8) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidS8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidS8) Observations + +```go +func (a *CmdVoidS8) Observations() *atom.Observations ``` #### func (*CmdVoidS8) Replay ```go -func (ϟa *CmdVoidS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidS8) String ```go -func (c *CmdVoidS8) String() string +func (a *CmdVoidS8) String() string ``` #### func (*CmdVoidS8) TypeID @@ -3155,6 +4806,7 @@ func (c *CmdVoidS8) TypeID() atom.TypeID ```go type CmdVoidString struct { binary.Generate + A string } ``` @@ -3166,9 +4818,7 @@ CmdVoidString #### func NewCmdVoidString ```go -func NewCmdVoidString( - pA string, -) *CmdVoidString +func NewCmdVoidString(A string) *CmdVoidString ``` #### func (*CmdVoidString) API @@ -3177,6 +4827,22 @@ func NewCmdVoidString( func (c *CmdVoidString) API() gfxapi.API ``` +#### func (*CmdVoidString) AddRead + +```go +func (a *CmdVoidString) AddRead(rng memory.Range, id binary.ID) *CmdVoidString +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidString pointer is returned so that calls can be chained. + +#### func (*CmdVoidString) AddWrite + +```go +func (a *CmdVoidString) AddWrite(rng memory.Range, id binary.ID) *CmdVoidString +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidString pointer is returned so that calls can be chained. + #### func (*CmdVoidString) Class ```go @@ -3192,19 +4858,25 @@ func (c *CmdVoidString) Flags() atom.Flags #### func (*CmdVoidString) Mutate ```go -func (ϟa *CmdVoidString) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidString) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidString) Observations + +```go +func (a *CmdVoidString) Observations() *atom.Observations ``` #### func (*CmdVoidString) Replay ```go -func (ϟa *CmdVoidString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidString) String ```go -func (c *CmdVoidString) String() string +func (a *CmdVoidString) String() string ``` #### func (*CmdVoidString) TypeID @@ -3218,6 +4890,7 @@ func (c *CmdVoidString) TypeID() atom.TypeID ```go type CmdVoidU16 struct { binary.Generate + A uint16 } ``` @@ -3229,9 +4902,7 @@ CmdVoidU16 #### func NewCmdVoidU16 ```go -func NewCmdVoidU16( - pA uint16, -) *CmdVoidU16 +func NewCmdVoidU16(A uint16) *CmdVoidU16 ``` #### func (*CmdVoidU16) API @@ -3240,6 +4911,22 @@ func NewCmdVoidU16( func (c *CmdVoidU16) API() gfxapi.API ``` +#### func (*CmdVoidU16) AddRead + +```go +func (a *CmdVoidU16) AddRead(rng memory.Range, id binary.ID) *CmdVoidU16 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidU16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidU16) AddWrite + +```go +func (a *CmdVoidU16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidU16 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidU16 pointer is returned so that calls can be chained. + #### func (*CmdVoidU16) Class ```go @@ -3255,19 +4942,25 @@ func (c *CmdVoidU16) Flags() atom.Flags #### func (*CmdVoidU16) Mutate ```go -func (ϟa *CmdVoidU16) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidU16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidU16) Observations + +```go +func (a *CmdVoidU16) Observations() *atom.Observations ``` #### func (*CmdVoidU16) Replay ```go -func (ϟa *CmdVoidU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidU16) String ```go -func (c *CmdVoidU16) String() string +func (a *CmdVoidU16) String() string ``` #### func (*CmdVoidU16) TypeID @@ -3281,6 +4974,7 @@ func (c *CmdVoidU16) TypeID() atom.TypeID ```go type CmdVoidU32 struct { binary.Generate + A uint32 } ``` @@ -3292,9 +4986,7 @@ CmdVoidU32 #### func NewCmdVoidU32 ```go -func NewCmdVoidU32( - pA uint32, -) *CmdVoidU32 +func NewCmdVoidU32(A uint32) *CmdVoidU32 ``` #### func (*CmdVoidU32) API @@ -3303,6 +4995,22 @@ func NewCmdVoidU32( func (c *CmdVoidU32) API() gfxapi.API ``` +#### func (*CmdVoidU32) AddRead + +```go +func (a *CmdVoidU32) AddRead(rng memory.Range, id binary.ID) *CmdVoidU32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidU32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidU32) AddWrite + +```go +func (a *CmdVoidU32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidU32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidU32 pointer is returned so that calls can be chained. + #### func (*CmdVoidU32) Class ```go @@ -3318,19 +5026,25 @@ func (c *CmdVoidU32) Flags() atom.Flags #### func (*CmdVoidU32) Mutate ```go -func (ϟa *CmdVoidU32) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidU32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidU32) Observations + +```go +func (a *CmdVoidU32) Observations() *atom.Observations ``` #### func (*CmdVoidU32) Replay ```go -func (ϟa *CmdVoidU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidU32) String ```go -func (c *CmdVoidU32) String() string +func (a *CmdVoidU32) String() string ``` #### func (*CmdVoidU32) TypeID @@ -3344,6 +5058,7 @@ func (c *CmdVoidU32) TypeID() atom.TypeID ```go type CmdVoidU64 struct { binary.Generate + A uint64 } ``` @@ -3355,9 +5070,7 @@ CmdVoidU64 #### func NewCmdVoidU64 ```go -func NewCmdVoidU64( - pA uint64, -) *CmdVoidU64 +func NewCmdVoidU64(A uint64) *CmdVoidU64 ``` #### func (*CmdVoidU64) API @@ -3366,6 +5079,22 @@ func NewCmdVoidU64( func (c *CmdVoidU64) API() gfxapi.API ``` +#### func (*CmdVoidU64) AddRead + +```go +func (a *CmdVoidU64) AddRead(rng memory.Range, id binary.ID) *CmdVoidU64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidU64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidU64) AddWrite + +```go +func (a *CmdVoidU64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidU64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidU64 pointer is returned so that calls can be chained. + #### func (*CmdVoidU64) Class ```go @@ -3381,19 +5110,25 @@ func (c *CmdVoidU64) Flags() atom.Flags #### func (*CmdVoidU64) Mutate ```go -func (ϟa *CmdVoidU64) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidU64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidU64) Observations + +```go +func (a *CmdVoidU64) Observations() *atom.Observations ``` #### func (*CmdVoidU64) Replay ```go -func (ϟa *CmdVoidU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidU64) String ```go -func (c *CmdVoidU64) String() string +func (a *CmdVoidU64) String() string ``` #### func (*CmdVoidU64) TypeID @@ -3407,6 +5142,7 @@ func (c *CmdVoidU64) TypeID() atom.TypeID ```go type CmdVoidU8 struct { binary.Generate + A uint8 } ``` @@ -3418,9 +5154,7 @@ CmdVoidU8 #### func NewCmdVoidU8 ```go -func NewCmdVoidU8( - pA uint8, -) *CmdVoidU8 +func NewCmdVoidU8(A uint8) *CmdVoidU8 ``` #### func (*CmdVoidU8) API @@ -3429,6 +5163,22 @@ func NewCmdVoidU8( func (c *CmdVoidU8) API() gfxapi.API ``` +#### func (*CmdVoidU8) AddRead + +```go +func (a *CmdVoidU8) AddRead(rng memory.Range, id binary.ID) *CmdVoidU8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidU8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidU8) AddWrite + +```go +func (a *CmdVoidU8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidU8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidU8 pointer is returned so that calls can be chained. + #### func (*CmdVoidU8) Class ```go @@ -3444,19 +5194,25 @@ func (c *CmdVoidU8) Flags() atom.Flags #### func (*CmdVoidU8) Mutate ```go -func (ϟa *CmdVoidU8) Mutate(ϟs *gfxapi.State) error +func (ϟa *CmdVoidU8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidU8) Observations + +```go +func (a *CmdVoidU8) Observations() *atom.Observations ``` #### func (*CmdVoidU8) Replay ```go -func (ϟa *CmdVoidU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool) +func (ϟa *CmdVoidU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error ``` #### func (*CmdVoidU8) String ```go -func (c *CmdVoidU8) String() string +func (a *CmdVoidU8) String() string ``` #### func (*CmdVoidU8) TypeID @@ -3465,30 +5221,1386 @@ func (c *CmdVoidU8) String() string func (c *CmdVoidU8) TypeID() atom.TypeID ``` -#### type F32Array +#### type CmdVoidWriteBool + +```go +type CmdVoidWriteBool struct { + binary.Generate + + A Boolᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteBool +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteBool + +```go +func NewCmdVoidWriteBool(A memory.Pointer) *CmdVoidWriteBool +``` + +#### func (*CmdVoidWriteBool) API + +```go +func (c *CmdVoidWriteBool) API() gfxapi.API +``` + +#### func (*CmdVoidWriteBool) AddRead + +```go +func (a *CmdVoidWriteBool) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteBool +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteBool pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteBool) AddWrite + +```go +func (a *CmdVoidWriteBool) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteBool +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteBool pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteBool) Class + +```go +func (*CmdVoidWriteBool) Class() binary.Class +``` + +#### func (*CmdVoidWriteBool) Flags + +```go +func (c *CmdVoidWriteBool) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteBool) Mutate + +```go +func (ϟa *CmdVoidWriteBool) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteBool) Observations + +```go +func (a *CmdVoidWriteBool) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteBool) Replay + +```go +func (ϟa *CmdVoidWriteBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteBool) String + +```go +func (a *CmdVoidWriteBool) String() string +``` + +#### func (*CmdVoidWriteBool) TypeID + +```go +func (c *CmdVoidWriteBool) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteF32 + +```go +type CmdVoidWriteF32 struct { + binary.Generate + + A F32ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteF32 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteF32 + +```go +func NewCmdVoidWriteF32(A memory.Pointer) *CmdVoidWriteF32 +``` + +#### func (*CmdVoidWriteF32) API + +```go +func (c *CmdVoidWriteF32) API() gfxapi.API +``` + +#### func (*CmdVoidWriteF32) AddRead + +```go +func (a *CmdVoidWriteF32) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteF32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteF32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteF32) AddWrite + +```go +func (a *CmdVoidWriteF32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteF32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteF32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteF32) Class + +```go +func (*CmdVoidWriteF32) Class() binary.Class +``` + +#### func (*CmdVoidWriteF32) Flags + +```go +func (c *CmdVoidWriteF32) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteF32) Mutate + +```go +func (ϟa *CmdVoidWriteF32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteF32) Observations + +```go +func (a *CmdVoidWriteF32) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteF32) Replay + +```go +func (ϟa *CmdVoidWriteF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteF32) String + +```go +func (a *CmdVoidWriteF32) String() string +``` + +#### func (*CmdVoidWriteF32) TypeID + +```go +func (c *CmdVoidWriteF32) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteF64 + +```go +type CmdVoidWriteF64 struct { + binary.Generate + + A F64ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteF64 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteF64 + +```go +func NewCmdVoidWriteF64(A memory.Pointer) *CmdVoidWriteF64 +``` + +#### func (*CmdVoidWriteF64) API + +```go +func (c *CmdVoidWriteF64) API() gfxapi.API +``` + +#### func (*CmdVoidWriteF64) AddRead + +```go +func (a *CmdVoidWriteF64) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteF64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteF64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteF64) AddWrite + +```go +func (a *CmdVoidWriteF64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteF64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteF64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteF64) Class + +```go +func (*CmdVoidWriteF64) Class() binary.Class +``` + +#### func (*CmdVoidWriteF64) Flags + +```go +func (c *CmdVoidWriteF64) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteF64) Mutate + +```go +func (ϟa *CmdVoidWriteF64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteF64) Observations + +```go +func (a *CmdVoidWriteF64) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteF64) Replay + +```go +func (ϟa *CmdVoidWriteF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteF64) String + +```go +func (a *CmdVoidWriteF64) String() string +``` + +#### func (*CmdVoidWriteF64) TypeID + +```go +func (c *CmdVoidWriteF64) TypeID() atom.TypeID +``` + +#### type CmdVoidWritePtrs + +```go +type CmdVoidWritePtrs struct { + binary.Generate + + A F32ᵖ + B U16ᵖ + C Boolᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWritePtrs +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWritePtrs + +```go +func NewCmdVoidWritePtrs(A memory.Pointer, B memory.Pointer, C memory.Pointer) *CmdVoidWritePtrs +``` + +#### func (*CmdVoidWritePtrs) API + +```go +func (c *CmdVoidWritePtrs) API() gfxapi.API +``` + +#### func (*CmdVoidWritePtrs) AddRead + +```go +func (a *CmdVoidWritePtrs) AddRead(rng memory.Range, id binary.ID) *CmdVoidWritePtrs +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWritePtrs pointer is returned so that calls can be chained. + +#### func (*CmdVoidWritePtrs) AddWrite + +```go +func (a *CmdVoidWritePtrs) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWritePtrs +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWritePtrs pointer is returned so that calls can be chained. + +#### func (*CmdVoidWritePtrs) Class + +```go +func (*CmdVoidWritePtrs) Class() binary.Class +``` + +#### func (*CmdVoidWritePtrs) Flags ```go -type F32Array []float32 +func (c *CmdVoidWritePtrs) Flags() atom.Flags ``` +#### func (*CmdVoidWritePtrs) Mutate -#### func (F32Array) Len +```go +func (ϟa *CmdVoidWritePtrs) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWritePtrs) Observations + +```go +func (a *CmdVoidWritePtrs) Observations() *atom.Observations +``` + +#### func (*CmdVoidWritePtrs) Replay + +```go +func (ϟa *CmdVoidWritePtrs) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWritePtrs) String + +```go +func (a *CmdVoidWritePtrs) String() string +``` + +#### func (*CmdVoidWritePtrs) TypeID + +```go +func (c *CmdVoidWritePtrs) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteS16 + +```go +type CmdVoidWriteS16 struct { + binary.Generate + + A S16ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteS16 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteS16 + +```go +func NewCmdVoidWriteS16(A memory.Pointer) *CmdVoidWriteS16 +``` + +#### func (*CmdVoidWriteS16) API + +```go +func (c *CmdVoidWriteS16) API() gfxapi.API +``` + +#### func (*CmdVoidWriteS16) AddRead + +```go +func (a *CmdVoidWriteS16) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteS16 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteS16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS16) AddWrite + +```go +func (a *CmdVoidWriteS16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteS16 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteS16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS16) Class + +```go +func (*CmdVoidWriteS16) Class() binary.Class +``` + +#### func (*CmdVoidWriteS16) Flags + +```go +func (c *CmdVoidWriteS16) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteS16) Mutate ```go -func (s F32Array) Len() int +func (ϟa *CmdVoidWriteS16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error ``` -#### func (F32Array) Range +#### func (*CmdVoidWriteS16) Observations ```go -func (s F32Array) Range() []float32 +func (a *CmdVoidWriteS16) Observations() *atom.Observations ``` +#### func (*CmdVoidWriteS16) Replay + +```go +func (ϟa *CmdVoidWriteS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteS16) String + +```go +func (a *CmdVoidWriteS16) String() string +``` + +#### func (*CmdVoidWriteS16) TypeID + +```go +func (c *CmdVoidWriteS16) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteS32 + +```go +type CmdVoidWriteS32 struct { + binary.Generate + + A S32ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteS32 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteS32 + +```go +func NewCmdVoidWriteS32(A memory.Pointer) *CmdVoidWriteS32 +``` + +#### func (*CmdVoidWriteS32) API + +```go +func (c *CmdVoidWriteS32) API() gfxapi.API +``` + +#### func (*CmdVoidWriteS32) AddRead + +```go +func (a *CmdVoidWriteS32) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteS32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteS32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS32) AddWrite + +```go +func (a *CmdVoidWriteS32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteS32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteS32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS32) Class + +```go +func (*CmdVoidWriteS32) Class() binary.Class +``` + +#### func (*CmdVoidWriteS32) Flags + +```go +func (c *CmdVoidWriteS32) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteS32) Mutate + +```go +func (ϟa *CmdVoidWriteS32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteS32) Observations + +```go +func (a *CmdVoidWriteS32) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteS32) Replay + +```go +func (ϟa *CmdVoidWriteS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteS32) String + +```go +func (a *CmdVoidWriteS32) String() string +``` + +#### func (*CmdVoidWriteS32) TypeID + +```go +func (c *CmdVoidWriteS32) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteS64 + +```go +type CmdVoidWriteS64 struct { + binary.Generate + + A S64ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteS64 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteS64 + +```go +func NewCmdVoidWriteS64(A memory.Pointer) *CmdVoidWriteS64 +``` + +#### func (*CmdVoidWriteS64) API + +```go +func (c *CmdVoidWriteS64) API() gfxapi.API +``` + +#### func (*CmdVoidWriteS64) AddRead + +```go +func (a *CmdVoidWriteS64) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteS64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteS64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS64) AddWrite + +```go +func (a *CmdVoidWriteS64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteS64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteS64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS64) Class + +```go +func (*CmdVoidWriteS64) Class() binary.Class +``` + +#### func (*CmdVoidWriteS64) Flags + +```go +func (c *CmdVoidWriteS64) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteS64) Mutate + +```go +func (ϟa *CmdVoidWriteS64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteS64) Observations + +```go +func (a *CmdVoidWriteS64) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteS64) Replay + +```go +func (ϟa *CmdVoidWriteS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteS64) String + +```go +func (a *CmdVoidWriteS64) String() string +``` + +#### func (*CmdVoidWriteS64) TypeID + +```go +func (c *CmdVoidWriteS64) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteS8 + +```go +type CmdVoidWriteS8 struct { + binary.Generate + + A S8ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteS8 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteS8 + +```go +func NewCmdVoidWriteS8(A memory.Pointer) *CmdVoidWriteS8 +``` + +#### func (*CmdVoidWriteS8) API + +```go +func (c *CmdVoidWriteS8) API() gfxapi.API +``` + +#### func (*CmdVoidWriteS8) AddRead + +```go +func (a *CmdVoidWriteS8) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteS8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteS8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS8) AddWrite + +```go +func (a *CmdVoidWriteS8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteS8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteS8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteS8) Class + +```go +func (*CmdVoidWriteS8) Class() binary.Class +``` + +#### func (*CmdVoidWriteS8) Flags + +```go +func (c *CmdVoidWriteS8) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteS8) Mutate + +```go +func (ϟa *CmdVoidWriteS8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteS8) Observations + +```go +func (a *CmdVoidWriteS8) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteS8) Replay + +```go +func (ϟa *CmdVoidWriteS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteS8) String + +```go +func (a *CmdVoidWriteS8) String() string +``` + +#### func (*CmdVoidWriteS8) TypeID + +```go +func (c *CmdVoidWriteS8) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteU16 + +```go +type CmdVoidWriteU16 struct { + binary.Generate + + A U16ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteU16 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteU16 + +```go +func NewCmdVoidWriteU16(A memory.Pointer) *CmdVoidWriteU16 +``` + +#### func (*CmdVoidWriteU16) API + +```go +func (c *CmdVoidWriteU16) API() gfxapi.API +``` + +#### func (*CmdVoidWriteU16) AddRead + +```go +func (a *CmdVoidWriteU16) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteU16 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteU16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU16) AddWrite + +```go +func (a *CmdVoidWriteU16) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteU16 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteU16 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU16) Class + +```go +func (*CmdVoidWriteU16) Class() binary.Class +``` + +#### func (*CmdVoidWriteU16) Flags + +```go +func (c *CmdVoidWriteU16) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteU16) Mutate + +```go +func (ϟa *CmdVoidWriteU16) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteU16) Observations + +```go +func (a *CmdVoidWriteU16) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteU16) Replay + +```go +func (ϟa *CmdVoidWriteU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteU16) String + +```go +func (a *CmdVoidWriteU16) String() string +``` + +#### func (*CmdVoidWriteU16) TypeID + +```go +func (c *CmdVoidWriteU16) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteU32 + +```go +type CmdVoidWriteU32 struct { + binary.Generate + + A U32ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteU32 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteU32 + +```go +func NewCmdVoidWriteU32(A memory.Pointer) *CmdVoidWriteU32 +``` + +#### func (*CmdVoidWriteU32) API + +```go +func (c *CmdVoidWriteU32) API() gfxapi.API +``` + +#### func (*CmdVoidWriteU32) AddRead + +```go +func (a *CmdVoidWriteU32) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteU32 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteU32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU32) AddWrite + +```go +func (a *CmdVoidWriteU32) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteU32 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteU32 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU32) Class + +```go +func (*CmdVoidWriteU32) Class() binary.Class +``` + +#### func (*CmdVoidWriteU32) Flags + +```go +func (c *CmdVoidWriteU32) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteU32) Mutate + +```go +func (ϟa *CmdVoidWriteU32) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteU32) Observations + +```go +func (a *CmdVoidWriteU32) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteU32) Replay + +```go +func (ϟa *CmdVoidWriteU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteU32) String + +```go +func (a *CmdVoidWriteU32) String() string +``` + +#### func (*CmdVoidWriteU32) TypeID + +```go +func (c *CmdVoidWriteU32) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteU64 + +```go +type CmdVoidWriteU64 struct { + binary.Generate + + A U64ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteU64 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteU64 + +```go +func NewCmdVoidWriteU64(A memory.Pointer) *CmdVoidWriteU64 +``` + +#### func (*CmdVoidWriteU64) API + +```go +func (c *CmdVoidWriteU64) API() gfxapi.API +``` + +#### func (*CmdVoidWriteU64) AddRead + +```go +func (a *CmdVoidWriteU64) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteU64 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteU64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU64) AddWrite + +```go +func (a *CmdVoidWriteU64) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteU64 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteU64 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU64) Class + +```go +func (*CmdVoidWriteU64) Class() binary.Class +``` + +#### func (*CmdVoidWriteU64) Flags + +```go +func (c *CmdVoidWriteU64) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteU64) Mutate + +```go +func (ϟa *CmdVoidWriteU64) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteU64) Observations + +```go +func (a *CmdVoidWriteU64) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteU64) Replay + +```go +func (ϟa *CmdVoidWriteU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteU64) String + +```go +func (a *CmdVoidWriteU64) String() string +``` + +#### func (*CmdVoidWriteU64) TypeID + +```go +func (c *CmdVoidWriteU64) TypeID() atom.TypeID +``` + +#### type CmdVoidWriteU8 + +```go +type CmdVoidWriteU8 struct { + binary.Generate + + A U8ᵖ +} +``` + +////////////////////////////////////////////////////////////////////////////// +CmdVoidWriteU8 +////////////////////////////////////////////////////////////////////////////// + +#### func NewCmdVoidWriteU8 + +```go +func NewCmdVoidWriteU8(A memory.Pointer) *CmdVoidWriteU8 +``` + +#### func (*CmdVoidWriteU8) API + +```go +func (c *CmdVoidWriteU8) API() gfxapi.API +``` + +#### func (*CmdVoidWriteU8) AddRead + +```go +func (a *CmdVoidWriteU8) AddRead(rng memory.Range, id binary.ID) *CmdVoidWriteU8 +``` +AddRead appends a new read observation to the atom of the range rng with the +data id. The CmdVoidWriteU8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU8) AddWrite + +```go +func (a *CmdVoidWriteU8) AddWrite(rng memory.Range, id binary.ID) *CmdVoidWriteU8 +``` +AddWrite appends a new write observation to the atom of the range rng with the +data id. The CmdVoidWriteU8 pointer is returned so that calls can be chained. + +#### func (*CmdVoidWriteU8) Class + +```go +func (*CmdVoidWriteU8) Class() binary.Class +``` + +#### func (*CmdVoidWriteU8) Flags + +```go +func (c *CmdVoidWriteU8) Flags() atom.Flags +``` + +#### func (*CmdVoidWriteU8) Mutate + +```go +func (ϟa *CmdVoidWriteU8) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) error +``` + +#### func (*CmdVoidWriteU8) Observations + +```go +func (a *CmdVoidWriteU8) Observations() *atom.Observations +``` + +#### func (*CmdVoidWriteU8) Replay + +```go +func (ϟa *CmdVoidWriteU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) error +``` + +#### func (*CmdVoidWriteU8) String + +```go +func (a *CmdVoidWriteU8) String() string +``` + +#### func (*CmdVoidWriteU8) TypeID + +```go +func (c *CmdVoidWriteU8) TypeID() atom.TypeID +``` + +#### type F32ˢ + +```go +type F32ˢ struct { + binary.Generate + SliceInfo +} +``` + +F32ˢ is a slice of float32. + +#### func AsF32ˢ + +```go +func AsF32ˢ(s Slice, ϟs *gfxapi.State) F32ˢ +``` +AsF32ˢ returns s cast to a F32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeF32ˢ + +```go +func MakeF32ˢ(count uint64, ϟs *gfxapi.State) F32ˢ +``` +MakeF32ˢ returns a F32ˢ backed by a new memory pool. + +#### func (*F32ˢ) Class + +```go +func (*F32ˢ) Class() binary.Class +``` + +#### func (F32ˢ) Clone + +```go +func (s F32ˢ) Clone(ϟs *gfxapi.State) F32ˢ +``` +Clone returns a copy of the F32ˢ in a new memory pool. + +#### func (F32ˢ) Copy + +```go +func (dst F32ˢ) Copy(src F32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s F32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (F32ˢ) Decoder + +```go +func (s F32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (F32ˢ) ElementSize + +```go +func (s F32ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F32ˢ points to. + +#### func (F32ˢ) Encoder + +```go +func (s F32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (F32ˢ) Index + +```go +func (s F32ˢ) Index(i uint64, ϟs *gfxapi.State) F32ᵖ +``` +Index returns a F32ᵖ to the i'th element in this F32ˢ. + +#### func (F32ˢ) Range + +```go +func (s F32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (F32ˢ) Read + +```go +func (s F32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []float32 +``` +Read reads and returns all the float32 elements in this F32ˢ. + +#### func (F32ˢ) ResourceID + +```go +func (s F32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (F32ˢ) Slice + +```go +func (s F32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) F32ˢ +``` +Slice returns a sub-slice from the F32ˢ using start and end indices. + +#### func (F32ˢ) String + +```go +func (s F32ˢ) String() string +``` +String returns a string description of the F32ˢ slice. + +#### func (F32ˢ) Write + +```go +func (dst F32ˢ) Write(src []float32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type F32ᵖ + +```go +type F32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +F32ᵖ is a pointer to a float32 element. + +#### func NewF32ᵖ + +```go +func NewF32ᵖ(addr memory.Pointer) F32ᵖ +``` +NewF32ᵖ returns a F32ᵖ that points to addr in the application pool. + +#### func (*F32ᵖ) Class + +```go +func (*F32ᵖ) Class() binary.Class +``` + +#### func (F32ᵖ) ElementSize + +```go +func (p F32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F32ᵖ points to. + +#### func (F32ᵖ) Read + +```go +func (p F32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) float32 +``` +Read reads and returns the float32 element at the pointer. + +#### func (F32ᵖ) Slice + +```go +func (p F32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) F32ˢ +``` +Slice returns a new F32ˢ from the pointer using start and end indices. + +#### func (F32ᵖ) String + +```go +func (p F32ᵖ) String() string +``` +String returns a string description of the F32ᵖ pointer. + +#### func (F32ᵖ) Write + +```go +func (p F32ᵖ) Write(value float32, ϟs *gfxapi.State) +``` +Write writes value to the float32 element at the pointer. + +#### type F64ˢ + +```go +type F64ˢ struct { + binary.Generate + SliceInfo +} +``` + +F64ˢ is a slice of float64. + +#### func AsF64ˢ + +```go +func AsF64ˢ(s Slice, ϟs *gfxapi.State) F64ˢ +``` +AsF64ˢ returns s cast to a F64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeF64ˢ + +```go +func MakeF64ˢ(count uint64, ϟs *gfxapi.State) F64ˢ +``` +MakeF64ˢ returns a F64ˢ backed by a new memory pool. + +#### func (*F64ˢ) Class + +```go +func (*F64ˢ) Class() binary.Class +``` + +#### func (F64ˢ) Clone + +```go +func (s F64ˢ) Clone(ϟs *gfxapi.State) F64ˢ +``` +Clone returns a copy of the F64ˢ in a new memory pool. + +#### func (F64ˢ) Copy + +```go +func (dst F64ˢ) Copy(src F64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s F64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (F64ˢ) Decoder + +```go +func (s F64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (F64ˢ) ElementSize + +```go +func (s F64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F64ˢ points to. + +#### func (F64ˢ) Encoder + +```go +func (s F64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (F64ˢ) Index + +```go +func (s F64ˢ) Index(i uint64, ϟs *gfxapi.State) F64ᵖ +``` +Index returns a F64ᵖ to the i'th element in this F64ˢ. + +#### func (F64ˢ) Range + +```go +func (s F64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (F64ˢ) Read + +```go +func (s F64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []float64 +``` +Read reads and returns all the float64 elements in this F64ˢ. + +#### func (F64ˢ) ResourceID + +```go +func (s F64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (F64ˢ) Slice + +```go +func (s F64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) F64ˢ +``` +Slice returns a sub-slice from the F64ˢ using start and end indices. + +#### func (F64ˢ) String + +```go +func (s F64ˢ) String() string +``` +String returns a string description of the F64ˢ slice. + +#### func (F64ˢ) Write + +```go +func (dst F64ˢ) Write(src []float64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type F64ᵖ + +```go +type F64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +F64ᵖ is a pointer to a float64 element. + +#### func NewF64ᵖ + +```go +func NewF64ᵖ(addr memory.Pointer) F64ᵖ +``` +NewF64ᵖ returns a F64ᵖ that points to addr in the application pool. + +#### func (*F64ᵖ) Class + +```go +func (*F64ᵖ) Class() binary.Class +``` + +#### func (F64ᵖ) ElementSize + +```go +func (p F64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that F64ᵖ points to. + +#### func (F64ᵖ) Read + +```go +func (p F64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) float64 +``` +Read reads and returns the float64 element at the pointer. + +#### func (F64ᵖ) Slice + +```go +func (p F64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) F64ˢ +``` +Slice returns a new F64ˢ from the pointer using start and end indices. + +#### func (F64ᵖ) String + +```go +func (p F64ᵖ) String() string +``` +String returns a string description of the F64ᵖ pointer. + +#### func (F64ᵖ) Write + +```go +func (p F64ᵖ) Write(value float64, ϟs *gfxapi.State) +``` +Write writes value to the float64 element at the pointer. + #### type Globals ```go type Globals struct { binary.Generate + U8s U8ˢ + U16s U16ˢ + U32s U32ˢ + Ints Intˢ + Str string } ``` @@ -3508,44 +6620,1180 @@ func (*Globals) Class() binary.Class func (g *Globals) Init() ``` -#### type RemappedArray +#### type Imported + +```go +type Imported struct { + binary.Generate + Value uint32 +} +``` + + +#### func (*Imported) Class + +```go +func (*Imported) Class() binary.Class +``` + +#### func (Imported) Init + +```go +func (Imported) Init() +``` + +#### type Included + +```go +type Included struct { + binary.Generate + CreatedAt atom.ID + S string +} +``` + +////////////////////////////////////////////////////////////////////////////// +class Included +////////////////////////////////////////////////////////////////////////////// + +#### func (*Included) Class + +```go +func (*Included) Class() binary.Class +``` + +#### func (*Included) GetCreatedAt + +```go +func (c *Included) GetCreatedAt() atom.ID +``` + +#### func (*Included) Init + +```go +func (c *Included) Init() +``` + +#### type Intˢ + +```go +type Intˢ struct { + binary.Generate + SliceInfo +} +``` + +Intˢ is a slice of int64. + +#### func AsIntˢ + +```go +func AsIntˢ(s Slice, ϟs *gfxapi.State) Intˢ +``` +AsIntˢ returns s cast to a Intˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeIntˢ + +```go +func MakeIntˢ(count uint64, ϟs *gfxapi.State) Intˢ +``` +MakeIntˢ returns a Intˢ backed by a new memory pool. + +#### func (*Intˢ) Class + +```go +func (*Intˢ) Class() binary.Class +``` + +#### func (Intˢ) Clone + +```go +func (s Intˢ) Clone(ϟs *gfxapi.State) Intˢ +``` +Clone returns a copy of the Intˢ in a new memory pool. + +#### func (Intˢ) Copy + +```go +func (dst Intˢ) Copy(src Intˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Intˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Intˢ) Decoder + +```go +func (s Intˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Intˢ) ElementSize + +```go +func (s Intˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Intˢ points to. + +#### func (Intˢ) Encoder + +```go +func (s Intˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Intˢ) Index + +```go +func (s Intˢ) Index(i uint64, ϟs *gfxapi.State) Intᵖ +``` +Index returns a Intᵖ to the i'th element in this Intˢ. + +#### func (Intˢ) Range + +```go +func (s Intˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Intˢ) Read + +```go +func (s Intˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int64 +``` +Read reads and returns all the int64 elements in this Intˢ. + +#### func (Intˢ) ResourceID + +```go +func (s Intˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Intˢ) Slice + +```go +func (s Intˢ) Slice(start, end uint64, ϟs *gfxapi.State) Intˢ +``` +Slice returns a sub-slice from the Intˢ using start and end indices. + +#### func (Intˢ) String + +```go +func (s Intˢ) String() string +``` +String returns a string description of the Intˢ slice. + +#### func (Intˢ) Write + +```go +func (dst Intˢ) Write(src []int64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Intᵖ + +```go +type Intᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Intᵖ is a pointer to a int64 element. + +#### func NewIntᵖ + +```go +func NewIntᵖ(addr memory.Pointer) Intᵖ +``` +NewIntᵖ returns a Intᵖ that points to addr in the application pool. + +#### func (*Intᵖ) Class + +```go +func (*Intᵖ) Class() binary.Class +``` + +#### func (Intᵖ) ElementSize + +```go +func (p Intᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Intᵖ points to. + +#### func (Intᵖ) Read + +```go +func (p Intᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int64 +``` +Read reads and returns the int64 element at the pointer. + +#### func (Intᵖ) Slice + +```go +func (p Intᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Intˢ +``` +Slice returns a new Intˢ from the pointer using start and end indices. + +#### func (Intᵖ) String + +```go +func (p Intᵖ) String() string +``` +String returns a string description of the Intᵖ pointer. + +#### func (Intᵖ) Write + +```go +func (p Intᵖ) Write(value int64, ϟs *gfxapi.State) +``` +Write writes value to the int64 element at the pointer. + +#### type Remappedˢ + +```go +type Remappedˢ struct { + binary.Generate + SliceInfo +} +``` + +Remappedˢ is a slice of remapped. + +#### func AsRemappedˢ + +```go +func AsRemappedˢ(s Slice, ϟs *gfxapi.State) Remappedˢ +``` +AsRemappedˢ returns s cast to a Remappedˢ. The returned slice length will be +calculated so that the returned slice is no longer (in bytes) than s. + +#### func MakeRemappedˢ + +```go +func MakeRemappedˢ(count uint64, ϟs *gfxapi.State) Remappedˢ +``` +MakeRemappedˢ returns a Remappedˢ backed by a new memory pool. + +#### func (*Remappedˢ) Class + +```go +func (*Remappedˢ) Class() binary.Class +``` + +#### func (Remappedˢ) Clone + +```go +func (s Remappedˢ) Clone(ϟs *gfxapi.State) Remappedˢ +``` +Clone returns a copy of the Remappedˢ in a new memory pool. + +#### func (Remappedˢ) Copy + +```go +func (dst Remappedˢ) Copy(src Remappedˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s Remappedˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (Remappedˢ) Decoder + +```go +func (s Remappedˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Remappedˢ) ElementSize + +```go +func (s Remappedˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Remappedˢ points to. + +#### func (Remappedˢ) Encoder + +```go +func (s Remappedˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Remappedˢ) Index + +```go +func (s Remappedˢ) Index(i uint64, ϟs *gfxapi.State) Remappedᵖ +``` +Index returns a Remappedᵖ to the i'th element in this Remappedˢ. + +#### func (Remappedˢ) Range + +```go +func (s Remappedˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Remappedˢ) Read + +```go +func (s Remappedˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []remapped +``` +Read reads and returns all the remapped elements in this Remappedˢ. + +#### func (Remappedˢ) ResourceID + +```go +func (s Remappedˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Remappedˢ) Slice ```go -type RemappedArray []remapped +func (s Remappedˢ) Slice(start, end uint64, ϟs *gfxapi.State) Remappedˢ ``` +Slice returns a sub-slice from the Remappedˢ using start and end indices. +#### func (Remappedˢ) String -#### func (RemappedArray) Len +```go +func (s Remappedˢ) String() string +``` +String returns a string description of the Remappedˢ slice. + +#### func (Remappedˢ) Write + +```go +func (dst Remappedˢ) Write(src []remapped, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type Remappedᵖ ```go -func (s RemappedArray) Len() int +type Remappedᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} ``` -#### func (RemappedArray) Range +Remappedᵖ is a pointer to a remapped element. + +#### func NewRemappedᵖ ```go -func (s RemappedArray) Range() []remapped +func NewRemappedᵖ(addr memory.Pointer) Remappedᵖ ``` +NewRemappedᵖ returns a Remappedᵖ that points to addr in the application pool. -#### type S8Array +#### func (*Remappedᵖ) Class ```go -type S8Array []int8 +func (*Remappedᵖ) Class() binary.Class ``` +#### func (Remappedᵖ) ElementSize -#### func (S8Array) Len +```go +func (p Remappedᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Remappedᵖ points to. + +#### func (Remappedᵖ) Read ```go -func (s S8Array) Len() int +func (p Remappedᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) remapped ``` +Read reads and returns the remapped element at the pointer. -#### func (S8Array) Range +#### func (Remappedᵖ) Slice ```go -func (s S8Array) Range() []int8 +func (p Remappedᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Remappedˢ +``` +Slice returns a new Remappedˢ from the pointer using start and end indices. + +#### func (Remappedᵖ) String + +```go +func (p Remappedᵖ) String() string +``` +String returns a string description of the Remappedᵖ pointer. + +#### func (Remappedᵖ) Write + +```go +func (p Remappedᵖ) Write(value remapped, ϟs *gfxapi.State) +``` +Write writes value to the remapped element at the pointer. + +#### type S16ˢ + +```go +type S16ˢ struct { + binary.Generate + SliceInfo +} ``` +S16ˢ is a slice of int16. + +#### func AsS16ˢ + +```go +func AsS16ˢ(s Slice, ϟs *gfxapi.State) S16ˢ +``` +AsS16ˢ returns s cast to a S16ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS16ˢ + +```go +func MakeS16ˢ(count uint64, ϟs *gfxapi.State) S16ˢ +``` +MakeS16ˢ returns a S16ˢ backed by a new memory pool. + +#### func (*S16ˢ) Class + +```go +func (*S16ˢ) Class() binary.Class +``` + +#### func (S16ˢ) Clone + +```go +func (s S16ˢ) Clone(ϟs *gfxapi.State) S16ˢ +``` +Clone returns a copy of the S16ˢ in a new memory pool. + +#### func (S16ˢ) Copy + +```go +func (dst S16ˢ) Copy(src S16ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S16ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S16ˢ) Decoder + +```go +func (s S16ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S16ˢ) ElementSize + +```go +func (s S16ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S16ˢ points to. + +#### func (S16ˢ) Encoder + +```go +func (s S16ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S16ˢ) Index + +```go +func (s S16ˢ) Index(i uint64, ϟs *gfxapi.State) S16ᵖ +``` +Index returns a S16ᵖ to the i'th element in this S16ˢ. + +#### func (S16ˢ) Range + +```go +func (s S16ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S16ˢ) Read + +```go +func (s S16ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int16 +``` +Read reads and returns all the int16 elements in this S16ˢ. + +#### func (S16ˢ) ResourceID + +```go +func (s S16ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S16ˢ) Slice + +```go +func (s S16ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S16ˢ +``` +Slice returns a sub-slice from the S16ˢ using start and end indices. + +#### func (S16ˢ) String + +```go +func (s S16ˢ) String() string +``` +String returns a string description of the S16ˢ slice. + +#### func (S16ˢ) Write + +```go +func (dst S16ˢ) Write(src []int16, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type S16ᵖ + +```go +type S16ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +S16ᵖ is a pointer to a int16 element. + +#### func NewS16ᵖ + +```go +func NewS16ᵖ(addr memory.Pointer) S16ᵖ +``` +NewS16ᵖ returns a S16ᵖ that points to addr in the application pool. + +#### func (*S16ᵖ) Class + +```go +func (*S16ᵖ) Class() binary.Class +``` + +#### func (S16ᵖ) ElementSize + +```go +func (p S16ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S16ᵖ points to. + +#### func (S16ᵖ) Read + +```go +func (p S16ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int16 +``` +Read reads and returns the int16 element at the pointer. + +#### func (S16ᵖ) Slice + +```go +func (p S16ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S16ˢ +``` +Slice returns a new S16ˢ from the pointer using start and end indices. + +#### func (S16ᵖ) String + +```go +func (p S16ᵖ) String() string +``` +String returns a string description of the S16ᵖ pointer. + +#### func (S16ᵖ) Write + +```go +func (p S16ᵖ) Write(value int16, ϟs *gfxapi.State) +``` +Write writes value to the int16 element at the pointer. + +#### type S32ˢ + +```go +type S32ˢ struct { + binary.Generate + SliceInfo +} +``` + +S32ˢ is a slice of int32. + +#### func AsS32ˢ + +```go +func AsS32ˢ(s Slice, ϟs *gfxapi.State) S32ˢ +``` +AsS32ˢ returns s cast to a S32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS32ˢ + +```go +func MakeS32ˢ(count uint64, ϟs *gfxapi.State) S32ˢ +``` +MakeS32ˢ returns a S32ˢ backed by a new memory pool. + +#### func (*S32ˢ) Class + +```go +func (*S32ˢ) Class() binary.Class +``` + +#### func (S32ˢ) Clone + +```go +func (s S32ˢ) Clone(ϟs *gfxapi.State) S32ˢ +``` +Clone returns a copy of the S32ˢ in a new memory pool. + +#### func (S32ˢ) Copy + +```go +func (dst S32ˢ) Copy(src S32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S32ˢ) Decoder + +```go +func (s S32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S32ˢ) ElementSize + +```go +func (s S32ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S32ˢ points to. + +#### func (S32ˢ) Encoder + +```go +func (s S32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S32ˢ) Index + +```go +func (s S32ˢ) Index(i uint64, ϟs *gfxapi.State) S32ᵖ +``` +Index returns a S32ᵖ to the i'th element in this S32ˢ. + +#### func (S32ˢ) Range + +```go +func (s S32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S32ˢ) Read + +```go +func (s S32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int32 +``` +Read reads and returns all the int32 elements in this S32ˢ. + +#### func (S32ˢ) ResourceID + +```go +func (s S32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S32ˢ) Slice + +```go +func (s S32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S32ˢ +``` +Slice returns a sub-slice from the S32ˢ using start and end indices. + +#### func (S32ˢ) String + +```go +func (s S32ˢ) String() string +``` +String returns a string description of the S32ˢ slice. + +#### func (S32ˢ) Write + +```go +func (dst S32ˢ) Write(src []int32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type S32ᵖ + +```go +type S32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +S32ᵖ is a pointer to a int32 element. + +#### func NewS32ᵖ + +```go +func NewS32ᵖ(addr memory.Pointer) S32ᵖ +``` +NewS32ᵖ returns a S32ᵖ that points to addr in the application pool. + +#### func (*S32ᵖ) Class + +```go +func (*S32ᵖ) Class() binary.Class +``` + +#### func (S32ᵖ) ElementSize + +```go +func (p S32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S32ᵖ points to. + +#### func (S32ᵖ) Read + +```go +func (p S32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int32 +``` +Read reads and returns the int32 element at the pointer. + +#### func (S32ᵖ) Slice + +```go +func (p S32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S32ˢ +``` +Slice returns a new S32ˢ from the pointer using start and end indices. + +#### func (S32ᵖ) String + +```go +func (p S32ᵖ) String() string +``` +String returns a string description of the S32ᵖ pointer. + +#### func (S32ᵖ) Write + +```go +func (p S32ᵖ) Write(value int32, ϟs *gfxapi.State) +``` +Write writes value to the int32 element at the pointer. + +#### type S64ˢ + +```go +type S64ˢ struct { + binary.Generate + SliceInfo +} +``` + +S64ˢ is a slice of int64. + +#### func AsS64ˢ + +```go +func AsS64ˢ(s Slice, ϟs *gfxapi.State) S64ˢ +``` +AsS64ˢ returns s cast to a S64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS64ˢ + +```go +func MakeS64ˢ(count uint64, ϟs *gfxapi.State) S64ˢ +``` +MakeS64ˢ returns a S64ˢ backed by a new memory pool. + +#### func (*S64ˢ) Class + +```go +func (*S64ˢ) Class() binary.Class +``` + +#### func (S64ˢ) Clone + +```go +func (s S64ˢ) Clone(ϟs *gfxapi.State) S64ˢ +``` +Clone returns a copy of the S64ˢ in a new memory pool. + +#### func (S64ˢ) Copy + +```go +func (dst S64ˢ) Copy(src S64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S64ˢ) Decoder + +```go +func (s S64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S64ˢ) ElementSize + +```go +func (s S64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S64ˢ points to. + +#### func (S64ˢ) Encoder + +```go +func (s S64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S64ˢ) Index + +```go +func (s S64ˢ) Index(i uint64, ϟs *gfxapi.State) S64ᵖ +``` +Index returns a S64ᵖ to the i'th element in this S64ˢ. + +#### func (S64ˢ) Range + +```go +func (s S64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S64ˢ) Read + +```go +func (s S64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int64 +``` +Read reads and returns all the int64 elements in this S64ˢ. + +#### func (S64ˢ) ResourceID + +```go +func (s S64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S64ˢ) Slice + +```go +func (s S64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S64ˢ +``` +Slice returns a sub-slice from the S64ˢ using start and end indices. + +#### func (S64ˢ) String + +```go +func (s S64ˢ) String() string +``` +String returns a string description of the S64ˢ slice. + +#### func (S64ˢ) Write + +```go +func (dst S64ˢ) Write(src []int64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type S64ᵖ + +```go +type S64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +S64ᵖ is a pointer to a int64 element. + +#### func NewS64ᵖ + +```go +func NewS64ᵖ(addr memory.Pointer) S64ᵖ +``` +NewS64ᵖ returns a S64ᵖ that points to addr in the application pool. + +#### func (*S64ᵖ) Class + +```go +func (*S64ᵖ) Class() binary.Class +``` + +#### func (S64ᵖ) ElementSize + +```go +func (p S64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S64ᵖ points to. + +#### func (S64ᵖ) Read + +```go +func (p S64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int64 +``` +Read reads and returns the int64 element at the pointer. + +#### func (S64ᵖ) Slice + +```go +func (p S64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S64ˢ +``` +Slice returns a new S64ˢ from the pointer using start and end indices. + +#### func (S64ᵖ) String + +```go +func (p S64ᵖ) String() string +``` +String returns a string description of the S64ᵖ pointer. + +#### func (S64ᵖ) Write + +```go +func (p S64ᵖ) Write(value int64, ϟs *gfxapi.State) +``` +Write writes value to the int64 element at the pointer. + +#### type S8ˢ + +```go +type S8ˢ struct { + binary.Generate + SliceInfo +} +``` + +S8ˢ is a slice of int8. + +#### func AsS8ˢ + +```go +func AsS8ˢ(s Slice, ϟs *gfxapi.State) S8ˢ +``` +AsS8ˢ returns s cast to a S8ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeS8ˢ + +```go +func MakeS8ˢ(count uint64, ϟs *gfxapi.State) S8ˢ +``` +MakeS8ˢ returns a S8ˢ backed by a new memory pool. + +#### func (*S8ˢ) Class + +```go +func (*S8ˢ) Class() binary.Class +``` + +#### func (S8ˢ) Clone + +```go +func (s S8ˢ) Clone(ϟs *gfxapi.State) S8ˢ +``` +Clone returns a copy of the S8ˢ in a new memory pool. + +#### func (S8ˢ) Copy + +```go +func (dst S8ˢ) Copy(src S8ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s S8ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (S8ˢ) Decoder + +```go +func (s S8ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (S8ˢ) ElementSize + +```go +func (s S8ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S8ˢ points to. + +#### func (S8ˢ) Encoder + +```go +func (s S8ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (S8ˢ) Index + +```go +func (s S8ˢ) Index(i uint64, ϟs *gfxapi.State) S8ᵖ +``` +Index returns a S8ᵖ to the i'th element in this S8ˢ. + +#### func (S8ˢ) Range + +```go +func (s S8ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (S8ˢ) Read + +```go +func (s S8ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []int8 +``` +Read reads and returns all the int8 elements in this S8ˢ. + +#### func (S8ˢ) ResourceID + +```go +func (s S8ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (S8ˢ) Slice + +```go +func (s S8ˢ) Slice(start, end uint64, ϟs *gfxapi.State) S8ˢ +``` +Slice returns a sub-slice from the S8ˢ using start and end indices. + +#### func (S8ˢ) String + +```go +func (s S8ˢ) String() string +``` +String returns a string description of the S8ˢ slice. + +#### func (S8ˢ) Write + +```go +func (dst S8ˢ) Write(src []int8, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type S8ᵖ + +```go +type S8ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +S8ᵖ is a pointer to a int8 element. + +#### func NewS8ᵖ + +```go +func NewS8ᵖ(addr memory.Pointer) S8ᵖ +``` +NewS8ᵖ returns a S8ᵖ that points to addr in the application pool. + +#### func (*S8ᵖ) Class + +```go +func (*S8ᵖ) Class() binary.Class +``` + +#### func (S8ᵖ) ElementSize + +```go +func (p S8ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that S8ᵖ points to. + +#### func (S8ᵖ) Read + +```go +func (p S8ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) int8 +``` +Read reads and returns the int8 element at the pointer. + +#### func (S8ᵖ) Slice + +```go +func (p S8ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) S8ˢ +``` +Slice returns a new S8ˢ from the pointer using start and end indices. + +#### func (S8ᵖ) String + +```go +func (p S8ᵖ) String() string +``` +String returns a string description of the S8ᵖ pointer. + +#### func (S8ᵖ) Write + +```go +func (p S8ᵖ) Write(value int8, ϟs *gfxapi.State) +``` +Write writes value to the int8 element at the pointer. + +#### type Slice + +```go +type Slice interface { + // Info returns the SliceInfo of this slice. + Info() SliceInfo + // ElementSize returns the size in bytes of a single element in the slice. + ElementSize(ϟs *gfxapi.State) uint64 +} +``` + +Slice is the interface implemented by all slice types + +#### type SliceInfo + +```go +type SliceInfo struct { + binary.Generate + Root memory.Pointer // Original pointer this slice derives from. + Base memory.Pointer // Address of first element. + Count uint64 // Number of elements in the slice. + Pool memory.PoolID // Pool that holds the element data. +} +``` + +SliceInfo is the common data between all slice types. + +#### func (*SliceInfo) Class + +```go +func (*SliceInfo) Class() binary.Class +``` + +#### func (SliceInfo) Info + +```go +func (s SliceInfo) Info() SliceInfo +``` +Info returns the SliceInfo. It is used to conform to the Slice interface. + #### type State ```go @@ -3556,21 +7804,889 @@ type State struct { ``` -#### type StringArray +#### type Tester + +```go +type Tester struct { + binary.Generate + CreatedAt atom.ID + A Imported + B Included +} +``` + +////////////////////////////////////////////////////////////////////////////// +class Tester +////////////////////////////////////////////////////////////////////////////// + +#### func (*Tester) Class + +```go +func (*Tester) Class() binary.Class +``` + +#### func (*Tester) GetCreatedAt + +```go +func (c *Tester) GetCreatedAt() atom.ID +``` + +#### func (*Tester) Init ```go -type StringArray []string +func (c *Tester) Init() +``` + +#### type U16ˢ + +```go +type U16ˢ struct { + binary.Generate + SliceInfo +} ``` +U16ˢ is a slice of uint16. + +#### func AsU16ˢ + +```go +func AsU16ˢ(s Slice, ϟs *gfxapi.State) U16ˢ +``` +AsU16ˢ returns s cast to a U16ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU16ˢ + +```go +func MakeU16ˢ(count uint64, ϟs *gfxapi.State) U16ˢ +``` +MakeU16ˢ returns a U16ˢ backed by a new memory pool. + +#### func (*U16ˢ) Class + +```go +func (*U16ˢ) Class() binary.Class +``` + +#### func (U16ˢ) Clone + +```go +func (s U16ˢ) Clone(ϟs *gfxapi.State) U16ˢ +``` +Clone returns a copy of the U16ˢ in a new memory pool. + +#### func (U16ˢ) Copy + +```go +func (dst U16ˢ) Copy(src U16ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U16ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U16ˢ) Decoder + +```go +func (s U16ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U16ˢ) ElementSize + +```go +func (s U16ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U16ˢ points to. + +#### func (U16ˢ) Encoder + +```go +func (s U16ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U16ˢ) Index + +```go +func (s U16ˢ) Index(i uint64, ϟs *gfxapi.State) U16ᵖ +``` +Index returns a U16ᵖ to the i'th element in this U16ˢ. + +#### func (U16ˢ) Range + +```go +func (s U16ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U16ˢ) Read + +```go +func (s U16ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint16 +``` +Read reads and returns all the uint16 elements in this U16ˢ. + +#### func (U16ˢ) ResourceID + +```go +func (s U16ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U16ˢ) Slice + +```go +func (s U16ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U16ˢ +``` +Slice returns a sub-slice from the U16ˢ using start and end indices. + +#### func (U16ˢ) String + +```go +func (s U16ˢ) String() string +``` +String returns a string description of the U16ˢ slice. + +#### func (U16ˢ) Write + +```go +func (dst U16ˢ) Write(src []uint16, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U16ᵖ + +```go +type U16ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U16ᵖ is a pointer to a uint16 element. + +#### func NewU16ᵖ + +```go +func NewU16ᵖ(addr memory.Pointer) U16ᵖ +``` +NewU16ᵖ returns a U16ᵖ that points to addr in the application pool. + +#### func (*U16ᵖ) Class + +```go +func (*U16ᵖ) Class() binary.Class +``` + +#### func (U16ᵖ) ElementSize + +```go +func (p U16ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U16ᵖ points to. + +#### func (U16ᵖ) Read + +```go +func (p U16ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint16 +``` +Read reads and returns the uint16 element at the pointer. + +#### func (U16ᵖ) Slice + +```go +func (p U16ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U16ˢ +``` +Slice returns a new U16ˢ from the pointer using start and end indices. + +#### func (U16ᵖ) String + +```go +func (p U16ᵖ) String() string +``` +String returns a string description of the U16ᵖ pointer. + +#### func (U16ᵖ) Write + +```go +func (p U16ᵖ) Write(value uint16, ϟs *gfxapi.State) +``` +Write writes value to the uint16 element at the pointer. + +#### type U32ˢ + +```go +type U32ˢ struct { + binary.Generate + SliceInfo +} +``` + +U32ˢ is a slice of uint32. + +#### func AsU32ˢ + +```go +func AsU32ˢ(s Slice, ϟs *gfxapi.State) U32ˢ +``` +AsU32ˢ returns s cast to a U32ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU32ˢ + +```go +func MakeU32ˢ(count uint64, ϟs *gfxapi.State) U32ˢ +``` +MakeU32ˢ returns a U32ˢ backed by a new memory pool. + +#### func (*U32ˢ) Class + +```go +func (*U32ˢ) Class() binary.Class +``` + +#### func (U32ˢ) Clone + +```go +func (s U32ˢ) Clone(ϟs *gfxapi.State) U32ˢ +``` +Clone returns a copy of the U32ˢ in a new memory pool. + +#### func (U32ˢ) Copy + +```go +func (dst U32ˢ) Copy(src U32ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U32ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U32ˢ) Decoder + +```go +func (s U32ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U32ˢ) ElementSize + +```go +func (s U32ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U32ˢ points to. + +#### func (U32ˢ) Encoder + +```go +func (s U32ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U32ˢ) Index + +```go +func (s U32ˢ) Index(i uint64, ϟs *gfxapi.State) U32ᵖ +``` +Index returns a U32ᵖ to the i'th element in this U32ˢ. + +#### func (U32ˢ) Range + +```go +func (s U32ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U32ˢ) Read + +```go +func (s U32ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint32 +``` +Read reads and returns all the uint32 elements in this U32ˢ. + +#### func (U32ˢ) ResourceID + +```go +func (s U32ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U32ˢ) Slice + +```go +func (s U32ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U32ˢ +``` +Slice returns a sub-slice from the U32ˢ using start and end indices. + +#### func (U32ˢ) String + +```go +func (s U32ˢ) String() string +``` +String returns a string description of the U32ˢ slice. + +#### func (U32ˢ) Write + +```go +func (dst U32ˢ) Write(src []uint32, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U32ᵖ + +```go +type U32ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U32ᵖ is a pointer to a uint32 element. + +#### func NewU32ᵖ + +```go +func NewU32ᵖ(addr memory.Pointer) U32ᵖ +``` +NewU32ᵖ returns a U32ᵖ that points to addr in the application pool. + +#### func (*U32ᵖ) Class + +```go +func (*U32ᵖ) Class() binary.Class +``` + +#### func (U32ᵖ) ElementSize + +```go +func (p U32ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U32ᵖ points to. + +#### func (U32ᵖ) Read + +```go +func (p U32ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint32 +``` +Read reads and returns the uint32 element at the pointer. + +#### func (U32ᵖ) Slice + +```go +func (p U32ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U32ˢ +``` +Slice returns a new U32ˢ from the pointer using start and end indices. + +#### func (U32ᵖ) String + +```go +func (p U32ᵖ) String() string +``` +String returns a string description of the U32ᵖ pointer. + +#### func (U32ᵖ) Write + +```go +func (p U32ᵖ) Write(value uint32, ϟs *gfxapi.State) +``` +Write writes value to the uint32 element at the pointer. + +#### type U64ˢ + +```go +type U64ˢ struct { + binary.Generate + SliceInfo +} +``` + +U64ˢ is a slice of uint64. + +#### func AsU64ˢ + +```go +func AsU64ˢ(s Slice, ϟs *gfxapi.State) U64ˢ +``` +AsU64ˢ returns s cast to a U64ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU64ˢ + +```go +func MakeU64ˢ(count uint64, ϟs *gfxapi.State) U64ˢ +``` +MakeU64ˢ returns a U64ˢ backed by a new memory pool. + +#### func (*U64ˢ) Class + +```go +func (*U64ˢ) Class() binary.Class +``` + +#### func (U64ˢ) Clone + +```go +func (s U64ˢ) Clone(ϟs *gfxapi.State) U64ˢ +``` +Clone returns a copy of the U64ˢ in a new memory pool. + +#### func (U64ˢ) Copy + +```go +func (dst U64ˢ) Copy(src U64ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U64ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U64ˢ) Decoder + +```go +func (s U64ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U64ˢ) ElementSize + +```go +func (s U64ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U64ˢ points to. + +#### func (U64ˢ) Encoder + +```go +func (s U64ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U64ˢ) Index + +```go +func (s U64ˢ) Index(i uint64, ϟs *gfxapi.State) U64ᵖ +``` +Index returns a U64ᵖ to the i'th element in this U64ˢ. + +#### func (U64ˢ) Range + +```go +func (s U64ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U64ˢ) Read + +```go +func (s U64ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint64 +``` +Read reads and returns all the uint64 elements in this U64ˢ. + +#### func (U64ˢ) ResourceID + +```go +func (s U64ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U64ˢ) Slice + +```go +func (s U64ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U64ˢ +``` +Slice returns a sub-slice from the U64ˢ using start and end indices. + +#### func (U64ˢ) String + +```go +func (s U64ˢ) String() string +``` +String returns a string description of the U64ˢ slice. + +#### func (U64ˢ) Write + +```go +func (dst U64ˢ) Write(src []uint64, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U64ᵖ + +```go +type U64ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U64ᵖ is a pointer to a uint64 element. + +#### func NewU64ᵖ + +```go +func NewU64ᵖ(addr memory.Pointer) U64ᵖ +``` +NewU64ᵖ returns a U64ᵖ that points to addr in the application pool. + +#### func (*U64ᵖ) Class + +```go +func (*U64ᵖ) Class() binary.Class +``` + +#### func (U64ᵖ) ElementSize + +```go +func (p U64ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U64ᵖ points to. + +#### func (U64ᵖ) Read + +```go +func (p U64ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint64 +``` +Read reads and returns the uint64 element at the pointer. + +#### func (U64ᵖ) Slice + +```go +func (p U64ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U64ˢ +``` +Slice returns a new U64ˢ from the pointer using start and end indices. + +#### func (U64ᵖ) String + +```go +func (p U64ᵖ) String() string +``` +String returns a string description of the U64ᵖ pointer. + +#### func (U64ᵖ) Write + +```go +func (p U64ᵖ) Write(value uint64, ϟs *gfxapi.State) +``` +Write writes value to the uint64 element at the pointer. + +#### type U8ˢ + +```go +type U8ˢ struct { + binary.Generate + SliceInfo +} +``` + +U8ˢ is a slice of uint8. + +#### func AsU8ˢ + +```go +func AsU8ˢ(s Slice, ϟs *gfxapi.State) U8ˢ +``` +AsU8ˢ returns s cast to a U8ˢ. The returned slice length will be calculated so +that the returned slice is no longer (in bytes) than s. + +#### func MakeU8ˢ + +```go +func MakeU8ˢ(count uint64, ϟs *gfxapi.State) U8ˢ +``` +MakeU8ˢ returns a U8ˢ backed by a new memory pool. + +#### func (*U8ˢ) Class + +```go +func (*U8ˢ) Class() binary.Class +``` + +#### func (U8ˢ) Clone + +```go +func (s U8ˢ) Clone(ϟs *gfxapi.State) U8ˢ +``` +Clone returns a copy of the U8ˢ in a new memory pool. + +#### func (U8ˢ) Copy + +```go +func (dst U8ˢ) Copy(src U8ˢ, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) (d, s U8ˢ) +``` +Copy copies elements from src to this slice. The number of elements copied is +the minimum of dst.Count and src.Count. The slices of this and dst to the copied +elements is returned. + +#### func (U8ˢ) Decoder + +```go +func (s U8ˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (U8ˢ) ElementSize + +```go +func (s U8ˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U8ˢ points to. + +#### func (U8ˢ) Encoder + +```go +func (s U8ˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (U8ˢ) Index + +```go +func (s U8ˢ) Index(i uint64, ϟs *gfxapi.State) U8ᵖ +``` +Index returns a U8ᵖ to the i'th element in this U8ˢ. + +#### func (U8ˢ) Range + +```go +func (s U8ˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (U8ˢ) Read + +```go +func (s U8ˢ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) []uint8 +``` +Read reads and returns all the uint8 elements in this U8ˢ. + +#### func (U8ˢ) ResourceID + +```go +func (s U8ˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (U8ˢ) Slice + +```go +func (s U8ˢ) Slice(start, end uint64, ϟs *gfxapi.State) U8ˢ +``` +Slice returns a sub-slice from the U8ˢ using start and end indices. + +#### func (U8ˢ) String + +```go +func (s U8ˢ) String() string +``` +String returns a string description of the U8ˢ slice. + +#### func (U8ˢ) Write + +```go +func (dst U8ˢ) Write(src []uint8, ϟs *gfxapi.State) uint64 +``` +Write copies elements from src to this slice. The number of elements copied is +returned which is the minimum of dst.Count and src.Count. + +#### type U8ᵖ + +```go +type U8ᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +U8ᵖ is a pointer to a uint8 element. + +#### func NewU8ᵖ + +```go +func NewU8ᵖ(addr memory.Pointer) U8ᵖ +``` +NewU8ᵖ returns a U8ᵖ that points to addr in the application pool. + +#### func (*U8ᵖ) Class + +```go +func (*U8ᵖ) Class() binary.Class +``` + +#### func (U8ᵖ) ElementSize + +```go +func (p U8ᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that U8ᵖ points to. + +#### func (U8ᵖ) Read + +```go +func (p U8ᵖ) Read(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) uint8 +``` +Read reads and returns the uint8 element at the pointer. + +#### func (U8ᵖ) Slice + +```go +func (p U8ᵖ) Slice(start, end uint64, ϟs *gfxapi.State) U8ˢ +``` +Slice returns a new U8ˢ from the pointer using start and end indices. + +#### func (U8ᵖ) String + +```go +func (p U8ᵖ) String() string +``` +String returns a string description of the U8ᵖ pointer. + +#### func (U8ᵖ) Write + +```go +func (p U8ᵖ) Write(value uint8, ϟs *gfxapi.State) +``` +Write writes value to the uint8 element at the pointer. + +#### type Voidˢ + +```go +type Voidˢ struct { + binary.Generate + SliceInfo +} +``` + +Voidˢ is a slice of void. + +#### func MakeVoidˢ + +```go +func MakeVoidˢ(count uint64, ϟs *gfxapi.State) Voidˢ +``` +MakeVoidˢ returns a Voidˢ backed by a new memory pool. + +#### func (*Voidˢ) Class + +```go +func (*Voidˢ) Class() binary.Class +``` + +#### func (Voidˢ) Clone + +```go +func (s Voidˢ) Clone(ϟs *gfxapi.State) Voidˢ +``` +Clone returns a copy of the Voidˢ in a new memory pool. + +#### func (Voidˢ) Decoder + +```go +func (s Voidˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder +``` +Decoder returns a memory decoder for the slice. + +#### func (Voidˢ) ElementSize + +```go +func (s Voidˢ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Voidˢ points to. + +#### func (Voidˢ) Encoder + +```go +func (s Voidˢ) Encoder(ϟs *gfxapi.State) binary.Encoder +``` +Encoder returns a memory encoder for the slice. + +#### func (Voidˢ) Index + +```go +func (s Voidˢ) Index(i uint64, ϟs *gfxapi.State) Voidᵖ +``` +Index returns a Voidᵖ to the i'th element in this Voidˢ. + +#### func (Voidˢ) Range + +```go +func (s Voidˢ) Range(ϟs *gfxapi.State) memory.Range +``` +Range returns the memory range this slice represents in the underlying pool. + +#### func (Voidˢ) ResourceID + +```go +func (s Voidˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID +``` +ResourceID returns an identifier to a resource representing the data of this +slice. + +#### func (Voidˢ) Slice + +```go +func (s Voidˢ) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ +``` +Slice returns a sub-slice from the Voidˢ using start and end indices. + +#### func (Voidˢ) String + +```go +func (s Voidˢ) String() string +``` +String returns a string description of the Voidˢ slice. + +#### type Voidᵖ + +```go +type Voidᵖ struct { + binary.Generate + Address memory.Pointer + Pool memory.PoolID +} +``` + +Voidᵖ is a pointer to a void element. + +#### func NewVoidᵖ + +```go +func NewVoidᵖ(addr memory.Pointer) Voidᵖ +``` +NewVoidᵖ returns a Voidᵖ that points to addr in the application pool. + +#### func (*Voidᵖ) Class + +```go +func (*Voidᵖ) Class() binary.Class +``` + +#### func (Voidᵖ) ElementSize + +```go +func (p Voidᵖ) ElementSize(ϟs *gfxapi.State) uint64 +``` +ElementSize returns the size in bytes of an element that Voidᵖ points to. -#### func (StringArray) Len +#### func (Voidᵖ) Slice ```go -func (s StringArray) Len() int +func (p Voidᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Voidˢ ``` +Slice returns a new Voidˢ from the pointer using start and end indices. -#### func (StringArray) Range +#### func (Voidᵖ) String ```go -func (s StringArray) Range() []string +func (p Voidᵖ) String() string ``` +String returns a string description of the Voidᵖ pointer. diff --git a/image/README.md b/image/README.md index 223124530..8ceb9938a 100644 --- a/image/README.md +++ b/image/README.md @@ -40,6 +40,8 @@ converted image data is returned, otherwise an error is returned. ```go type Format interface { + binary.Object + Check(data []byte, width, height int) error } ``` diff --git a/integration/replay/utils/README.md b/integration/replay/utils/README.md index 58a5e4722..526a0c118 100644 --- a/integration/replay/utils/README.md +++ b/integration/replay/utils/README.md @@ -14,18 +14,10 @@ func FindLocalDevice(t *testing.T, mgr *replay.Manager) replay.Device FindLocalDevice returns the replay Device for the local host. If the local host cannot be found then the test fails and nil is returned. -#### func NewInMemoryDatabase - -```go -func NewInMemoryDatabase() database.Database -``` -NewInMemoryDatabase returns a partial implementation of Database, keeping all -entries in-memory. - #### func StoreCapture ```go -func StoreCapture(t *testing.T, atoms atom.List, db database.Database, l log.Logger) service.CaptureId +func StoreCapture(t *testing.T, atoms atom.List, d database.Database, l log.Logger) service.CaptureId ``` StoreCapture encodes and writes the atom list to the database, returning an identifier to the newly constructed and stored Capture. diff --git a/log/README.md b/log/README.md index 77881278b..7bc7666ec 100644 --- a/log/README.md +++ b/log/README.md @@ -64,10 +64,16 @@ const ( ) ``` +#### func (*Kind) Parse + +```go +func (v *Kind) Parse(s string) error +``` + #### func (Kind) String ```go -func (i Kind) String() string +func (v Kind) String() string ``` #### type Logger @@ -76,15 +82,15 @@ func (i Kind) String() string type Logger interface { // Info writes an information message to the logger. These message types are intented to be used // for non-critial, expected events. Arguments are handled in the manner of fmt.Printf. - Info(msg string, args ...interface{}) + Infof(msg string, args ...interface{}) // Warning writes a warning message to the logger. This is intented to be used for unexpected but // non-critical events. Arguments are handled in the manner of fmt.Printf. - Warning(msg string, args ...interface{}) + Warningf(msg string, args ...interface{}) // Error writes an error message to the logger. This is intented to be used for unexpected and // critical error events. Arguments are handled in the manner of fmt.Printf. - Error(msg string, args ...interface{}) + Errorf(msg string, args ...interface{}) // Enter creates a new logger scoped within the existing logger. This can be used to produce // hierarchical log messages. @@ -132,10 +138,17 @@ Std returns a Logger that writes to stdout and stderr. #### func Testing ```go -func Testing(t *testing.T) Logger +func Testing(t delegate) Logger ``` Testing returns a Logger that writes to t's log methods. +#### func Writer + +```go +func Writer(info, warn, err io.Writer, done func()) Logger +``` +Writer returns a Logger that writes to the supplied streams. + #### type Nop ```go @@ -159,10 +172,10 @@ func (Nop) Enter(name string) Logger ``` Enter returns the same Nop implementation of Logger -#### func (Nop) Error +#### func (Nop) Errorf ```go -func (Nop) Error(msg string, args ...interface{}) +func (Nop) Errorf(msg string, args ...interface{}) ``` Error does nothing @@ -180,17 +193,17 @@ func (Nop) Fork() Logger ``` Fork returns the same Nop implementation of Logger -#### func (Nop) Info +#### func (Nop) Infof ```go -func (Nop) Info(msg string, args ...interface{}) +func (Nop) Infof(msg string, args ...interface{}) ``` Info does nothing -#### func (Nop) Warning +#### func (Nop) Warningf ```go -func (Nop) Warning(msg string, args ...interface{}) +func (Nop) Warningf(msg string, args ...interface{}) ``` Warning does nothing @@ -225,10 +238,10 @@ func (s *Splitter) Enter(name string) Logger ``` Enter will call Enter with the same argument on all logs passed to Add. -#### func (*Splitter) Error +#### func (*Splitter) Errorf ```go -func (s *Splitter) Error(msg string, args ...interface{}) +func (s *Splitter) Errorf(msg string, args ...interface{}) ``` Error will call Error with the same arguments on all logs passed to Add. @@ -246,16 +259,16 @@ func (s *Splitter) Fork() Logger ``` Fork will call Fork on all logs passed to Add. -#### func (*Splitter) Info +#### func (*Splitter) Infof ```go -func (s *Splitter) Info(msg string, args ...interface{}) +func (s *Splitter) Infof(msg string, args ...interface{}) ``` Info will call Info with the same arguments on all logs passed to Add. -#### func (*Splitter) Warning +#### func (*Splitter) Warningf ```go -func (s *Splitter) Warning(msg string, args ...interface{}) +func (s *Splitter) Warningf(msg string, args ...interface{}) ``` Warning will call Warning with the same arguments on all logs passed to Add. diff --git a/maker/README.md b/maker/README.md index e229b0ef6..285adf306 100644 --- a/maker/README.md +++ b/maker/README.md @@ -16,6 +16,10 @@ const ( ``` ```go +const GoPkgResources = "go_packages" +``` + +```go const HostExecutableExtension = "" ``` @@ -45,12 +49,10 @@ var ( Config struct { // Verbose enables increased logging output. Verbose int - // TargetArchitecture is the architecture to build binaries for. - TargetArchitecture string - // TargetOS is the OS to build for. - TargetOS string // DisableParallel turns of all parallel build support. DisableParallel bool + // StopOnError makes the system quit faster once an error has been found. + StopOnError bool } // Paths holds the set of path roots for the build. Paths struct { @@ -58,8 +60,6 @@ var ( Root string // The dependancy cache directory Deps string - // The application data directory. - Data string // The application binary directory. Bin string } @@ -355,6 +355,13 @@ func Creator(of interface{}) *Step Creator looks up the step that builds an entity. The entity will be looked up using EntityOf. +#### func GoCommand + +```go +func GoCommand(args ...string) *Step +``` +GoCommand runs "go" with the specified arguments. + #### func GoRun ```go @@ -379,6 +386,14 @@ func NewStep(a func(*Step) error) *Step ``` NewStep creates and returns a new step that runs the supplied action. +#### func (*Step) Access + +```go +func (s *Step) Access(v ...string) *Step +``` +Access adds the supplied shared resource names to the list of resources accessed +by this step. + #### func (*Step) AlwaysRun ```go @@ -412,6 +427,13 @@ DependsStruct adds all the fields of the supplied struct as input dependacies of the step. It is an error if the struct has any fields that are not public fields of types that implement Entity. +#### func (*Step) Disable + +```go +func (s *Step) Disable() *Step +``` +Disable marks a step as disabled, so it will not run. + #### func (*Step) HasInput ```go @@ -433,7 +455,7 @@ outputs. ```go func (s *Step) String() string ``` -String returns the name of the first output if present, for debugging. +String returns the name of the first output if present, for logging. #### func (*Step) UseDepsFile diff --git a/memory/README.md b/memory/README.md index 4ed94354d..a72861b9a 100644 --- a/memory/README.md +++ b/memory/README.md @@ -7,100 +7,132 @@ observed in the capture. ## Usage -#### type Data - ```go -type Data interface { - Get(db database.Database, logger log.Logger) ([]byte, error) - Size() uint64 +var Tmp = Range{ + Base: 0x00000000ff000000, + Size: 0x0000000000ffffff, } ``` -Data is the interface for a data source that can be resolved to a byte slice -with Get. +#### func Reader -Size returns the number of bytes that would be returned by calling Get. +```go +func Reader(s Slice, d database.Database, l log.Logger) io.Reader +``` +Reader returns a binary reader for the specified Slice. -#### type DataSliceWriter +#### func Write ```go -type DataSliceWriter interface { - Data - Slice(r Range) DataSliceWriter - Write(d Data) -} +func Write(w binary.Writer, arch device.Architecture, v interface{}) error ``` +Write writes the value v to the writer w. If v is an array or slice, then each +of the elements will be written, sequentially. -DataSliceWriter is similar to DataSlicer, but also has the Write method for -modifying the data that the DataSliceWriter refers to. +#### func Writer -Write will replace the data in this DataSliceWriter with d. If d is shorter in -length than the slice, then only the range [0, d.Size()-1] bytes will be -replaced. A sliced DataSliceWriter shares the same data from which it was sliced -- i.e. any mutations to a DataSliceWriter will also affect the Data it was -sliced from. +```go +func Writer(p *Pool, rng Range) io.Writer +``` +Writer returns a binary writer for the specified memory pool and range. -#### type DataSlicer +#### type Pointer ```go -type DataSlicer interface { - Data - Slice(r Range) DataSlicer -} +type Pointer uint64 ``` -DataSlicer extends the Data interface with aditional support for slicing. +Pointer is the type representing a memory pointer. + +#### func (Pointer) Offset -Slice returns a new DataSlicer referencing a subset range of the data. The range -r is relative to the base of the DataSlicer. For example a slice of [0, 4] would -return a DataSlicer referencing the first 5 bytes of this DataSlicer. Attempting -to slice outside the range of this DataSlicer will result in a panic. +```go +func (p Pointer) Offset(n uint64) Pointer +``` +Offset returns the pointer offset by n bytes. + +#### func (Pointer) Range + +```go +func (p Pointer) Range(s uint64) Range +``` +Range returns a Range of size s with the base of this pointer. -#### func ResourceData +#### func (Pointer) String ```go -func ResourceData(resId binary.ID, size uint64) DataSlicer +func (p Pointer) String() string ``` -ResourceData returns a DataSlicer that wraps a resource. resId is the identifier -of the resource and size is the size in bytes of the resource. -#### type Memory +#### type Pool ```go -type Memory struct { +type Pool struct { binary.Generate `disable:"true"` } ``` -Memory represents an unbounded and isolated memory space. Memory can be used to -represent the application address space, or hidden GPU memory. +Pool represents an unbounded and isolated memory space. Pool can be used to +represent the application address space, or hidden GPU Pool. -Memory can be sliced into smaller regions which can be read or written to. All -writes to Memory or its slices do not actually perform binary data copies, but -instead all writes are stored as lightweight records. Only when a Memory slice -has Get called will any resolving, loading or copying of binary data occur. +Pool can be sliced into smaller regions which can be read or written to. All +writes to Pool or its slices do not actually perform binary data copies, but +instead all writes are stored as lightweight records. Only when a Pool slice has +Get called will any resolving, loading or copying of binary data occur. -#### func (*Memory) Slice +#### func (*Pool) At ```go -func (m *Memory) Slice(rng Range) DataSliceWriter +func (m *Pool) At(p Pointer) Slice ``` -Slice returns a DataSliceWriter referencing the subset of the Memory range. +At returns an unbounded Slice starting at p. -#### func (*Memory) Write +#### func (*Pool) Slice ```go -func (m *Memory) Write(d Data) +func (m *Pool) Slice(rng Range) Slice ``` -Write copies d to the Memory slice [0, d.Size()-1]. +Slice returns a Slice referencing the subset of the Pool range. -#### type Pointer +#### func (*Pool) String ```go -type Pointer uint64 +func (m *Pool) String() string ``` +String returns the full history of writes performed to this pool. -Pointer is the type representing a memory pointer. +#### func (*Pool) Write + +```go +func (m *Pool) Write(dst Pointer, src Slice) +``` +Write copies the slice src to dst. + +#### type PoolID + +```go +type PoolID uint32 +``` + +PoolID is an indentifier of a Pool. + +```go +const ApplicationPool PoolID = 0 +``` +ApplicationPool is the PoolID of Pool representing the application's memory +address space. + +#### func (*PoolID) Parse + +```go +func (v *PoolID) Parse(s string) error +``` + +#### func (PoolID) String + +```go +func (v PoolID) String() string +``` #### type Range @@ -127,6 +159,13 @@ func (i Range) Contains(p Pointer) bool ``` Contains returns true if the pointer p is within the Range. +#### func (Range) End + +```go +func (i Range) End() Pointer +``` +End returns a Pointer to one byte beyond the end of the Range. + #### func (Range) Expand ```go @@ -156,6 +195,13 @@ func (i Range) Last() Pointer ``` Last returns a Pointer to the last byte in the Range. +#### func (Range) Overlaps + +```go +func (i Range) Overlaps(other Range) bool +``` +Overlaps returns true if other overlaps this memory range. + #### func (Range) Span ```go @@ -210,3 +256,51 @@ Resize resizes the RangeList to the specified length. func (l *RangeList) SetSpan(index int, span interval.U64Span) ``` SetSpan adjusts the range of the span with the specified index in the RangeList. + +#### type Slice + +```go +type Slice interface { + // Get resolves all the bytes representing the slice. + Get(d database.Database, l log.Logger) ([]byte, error) + + // ResourceID returns the identifier of the resource representing the slice, + // creating a new resource if it isn't already backed by one. + ResourceID(d database.Database, l log.Logger) (binary.ID, error) + + // Size returns the number of bytes that would be returned by calling Get. + Size() uint64 + + // Slice returns a new Slice referencing a subset range of the data. + // The range r is relative to the base of the Slice. For example a slice of + // [0, 4] would return a Slice referencing the first 5 bytes of this Slice. + // Attempting to slice outside the range of this Slice will result in a + // panic. + Slice(r Range) Slice +} +``` + +Slice is the interface for a data source that can be resolved to a byte slice +with Get, or 'sliced' to a subset of the data source. + +#### func Blob + +```go +func Blob(data []byte) Slice +``` +Blob returns a read-only Slice that wraps data. + +#### func Data + +```go +func Data(arch device.Architecture, data ...interface{}) Slice +``` +Data returns a read-only Slice that contains the encoding of data. + +#### func Resource + +```go +func Resource(resId binary.ID, size uint64) Slice +``` +Resource returns a Slice that wraps a resource stored in the database. resId is +the identifier of the data and size is the size in bytes of the data. diff --git a/parse/README.md b/parse/README.md index 0147690b2..863b50aa3 100644 --- a/parse/README.md +++ b/parse/README.md @@ -136,6 +136,12 @@ ErrorList is a convenience type for managing lists of errors. func (l *ErrorList) Add(r *Reader, at Fragment, message string, args ...interface{}) ``` +#### func (ErrorList) Error + +```go +func (errs ErrorList) Error() string +``` + #### type Fragment ```go @@ -268,6 +274,18 @@ const ( ) ``` +#### func (*NumberKind) Parse + +```go +func (v *NumberKind) Parse(s string) error +``` + +#### func (NumberKind) String + +```go +func (v NumberKind) String() string +``` + #### type Parser ```go @@ -498,6 +516,18 @@ const ( ) ``` +#### func (*SkipMode) Parse + +```go +func (v *SkipMode) Parse(s string) error +``` + +#### func (SkipMode) String + +```go +func (v SkipMode) String() string +``` + #### type Token ```go diff --git a/replay/README.md b/replay/README.md index 4e8e5b53d..a74c20d20 100644 --- a/replay/README.md +++ b/replay/README.md @@ -16,13 +16,18 @@ for disabling the cache for tests. #### func Replay ```go -func Replay(id atom.ID, a atom.Atom, s *gfxapi.State, b *builder.Builder, postback bool) +func Replay( + i atom.ID, + a atom.Atom, + s *gfxapi.State, + d database.Database, + l log.Logger, + b *builder.Builder) error ``` Replay issues replay operations to the replay builder b for the given atom a -with identifier id, and graphics API state s. If replaying the Atom will have an +with identifier i, and graphics API state s. If replaying the Atom will have an effect on the graphics driver state, then the call to Replay will also apply the -corresponding changes to the state s. If postback is true then the replay -instructions should include postback of all outputs of the Atom. +corresponding changes to the state s. #### type CallTiming @@ -60,6 +65,58 @@ type Context struct { Context describes the source capture and replay target information used for issuing a replay request. +#### type Custom + +```go +type Custom func(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error +``` + +Custom is an atom issuing custom replay operations to the replay builder b upon +Replay(). + +#### func (Custom) API + +```go +func (Custom) API() gfxapi.API +``` +atom.Atom compliance + +#### func (Custom) Class + +```go +func (Custom) Class() binary.Class +``` + +#### func (Custom) Flags + +```go +func (Custom) Flags() atom.Flags +``` + +#### func (Custom) Mutate + +```go +func (Custom) Mutate(s *gfxapi.State, d database.Database, l log.Logger) error +``` + +#### func (Custom) Observations + +```go +func (Custom) Observations() *atom.Observations +``` + +#### func (Custom) Replay + +```go +func (c Custom) Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error +``` + +#### func (Custom) TypeID + +```go +func (Custom) TypeID() atom.TypeID +``` + #### type Device ```go @@ -70,8 +127,6 @@ type Device interface { Info() *service.Device // Connect opens a connection to the replay device. Connect() (io.ReadWriteCloser, error) - // ByteOrder returns a byte ordering object for the replay device. - ByteOrder() endian.ByteOrder } ``` @@ -90,7 +145,6 @@ type Generator interface { ctx Context, cfg Config, requests []Request, - postback Postback, device *service.Device, db database.Database, logger log.Logger) atom.Transforms @@ -124,7 +178,7 @@ discovered devices. #### func New ```go -func New(db database.Database, l log.Logger) *Manager +func New(d database.Database, l log.Logger) *Manager ``` New returns a new Manager instance using the database db and logger l. @@ -146,27 +200,6 @@ take some considerable time before it is executed. Replay requests made with configs that have equality (==) will likely be batched into the same replay pass. -#### type Postback - -```go -type Postback func(handler PostbackHandler) atom.ID -``` - -Postback registers handler to be called with the postback data for the atom with -the returned identifier. The returned atom identifier is unique, enforcing at -most one postback handler per atom. - -#### type PostbackHandler - -```go -type PostbackHandler func(data interface{}, err error) -``` - -PostbackHandler is a callback for an atom's postback data. If the postback was -successful then data holds the postback data, and err is nil. If the postback -failed to decode or was missing then data will be nil and err will be the error -raised. - #### type QueryCallDurations ```go @@ -205,12 +238,10 @@ content of the depth buffer at a particular point in a capture. ```go type Replayer interface { // Replay issues replay operations to the replay builder b for the given atom - // with identifier id, and graphics API state s. If the replay action will + // with identifier i, and graphics API state s. If the replay action will // have an effect on the graphics driver state, then the call to Replay should - // also apply the corresponding changes to the state s. If postback is true - // then the replay instructions should include postback of all outputs of the - // action. - Replay(id atom.ID, s *gfxapi.State, b *builder.Builder, postback bool) + // also apply the corresponding changes to the state s. + Replay(i atom.ID, s *gfxapi.State, d database.Database, l log.Logger, b *builder.Builder) error } ``` diff --git a/replay/asm/README.md b/replay/asm/README.md index 6488bcde8..1b3230ec6 100644 --- a/replay/asm/README.md +++ b/replay/asm/README.md @@ -7,6 +7,15 @@ machine. ## Usage +#### func Check + +```go +func Check(t *testing.T, got []Instruction, expected []Instruction) (matched bool) +``` +Check is a test helper function that checks the list of got instructions matches +those in expected. If any differences are found then these are logged to t, and +the test fails. + #### type Call ```go diff --git a/replay/builder/README.md b/replay/builder/README.md index 3f377c406..fc5294f78 100644 --- a/replay/builder/README.md +++ b/replay/builder/README.md @@ -27,11 +27,10 @@ functions and posting back data. #### func New ```go -func New(ptrSize, ptrAlignment int, byteOrder endian.ByteOrder) *Builder +func New(architecture device.Architecture) *Builder ``` -New returns a newly constructed Builder configured to replay on a target -architecture that has a pointer size of ptrSize bytes and and alignment of -ptrAlignment bytes, with byte ordering that matches byteOrder. +New returns a newly constructed Builder configured to replay on a target with +the specified Architecture. #### func (*Builder) AllocateMemory @@ -64,6 +63,13 @@ each of the allocated chunks and the size of the entire allocation. The allocation block will be freed on the next call to EndAtom, upon which reading or writing to this memory will result in undefined behavior. +#### func (*Builder) Architecture + +```go +func (b *Builder) Architecture() device.Architecture +``` +Architecture returns the architecture for the target replay device. + #### func (*Builder) BeginAtom ```go @@ -89,25 +95,15 @@ func (b *Builder) Build(logger log.Logger) (protocol.Payload, ResponseDecoder, e Build compiles the replay instructions, returning a Payload that can be sent to the replay virtual-machine and a ResponseDecoder for interpreting the responses. -#### func (*Builder) CallNoPush - -```go -func (b *Builder) CallNoPush(f FunctionInfo) -``` -CallNoPush will invoke the function f, popping all parameter values previously -pushed to the stack with Push, starting with the first parameter. Unlike -CallPush the return value of the function will not be pushed on to the stack and -functions with void return types are accepted. - -#### func (*Builder) CallPush +#### func (*Builder) Call ```go -func (b *Builder) CallPush(f FunctionInfo) +func (b *Builder) Call(f FunctionInfo) ``` -CallPush will invoke the function f, popping all parameter values previously -pushed to the stack with Push, starting with the first parameter. After invoking -the function the return value of the function will be pushed on to the stack. If -f has a void return type then CallPush will panic. +Call will invoke the function f, popping all parameter values previously pushed +to the stack with Push, starting with the first parameter. If f has a non-void +return type, after invoking the function the return value of the function will +be pushed on to the stack. #### func (*Builder) Clone @@ -117,22 +113,21 @@ func (b *Builder) Clone(index int) Clone makes a copy of the n-th element from the top of the stack and pushes the copy to the top of the stack. -#### func (*Builder) Copy +#### func (*Builder) CommitAtom ```go -func (b *Builder) Copy(size uint64) +func (b *Builder) CommitAtom() ``` -Copy pops the target address and then the source address from the top of the -stack, and then copies Count bytes from source to target. +CommitAtom should be called after emitting the commands to replay a single atom. +CommitAtom frees all temporary allocated memory and clears the stack. -#### func (*Builder) EndAtom +#### func (*Builder) Copy ```go -func (b *Builder) EndAtom() +func (b *Builder) Copy(size uint64) ``` -EndAtom should be called after emitting the commands to replay a single atom. -EndAtom frees all allocated temporary memory, and asserts the stack should be -empty. +Copy pops the target address and then the source address from the top of the +stack, and then copies Count bytes from source to target. #### func (*Builder) Load @@ -142,29 +137,12 @@ func (b *Builder) Load(ty protocol.Type, addr value.Pointer) Load loads the value of type ty from addr and then pushes the loaded value to the top of the stack. -#### func (*Builder) Observation - -```go -func (b *Builder) Observation(rng memory.Range, resourceID binary.ID) -``` -Observation fills the memory range in capture address-space rng with the data of -resourceID. - -#### func (*Builder) PointerAlignment - -```go -func (b *Builder) PointerAlignment() int -``` -PointerAlignment returns the required alignment of a pointer in bytes for the -replay target architecture. - -#### func (*Builder) PointerSize +#### func (*Builder) MapMemory ```go -func (b *Builder) PointerSize() int +func (b *Builder) MapMemory(rng memory.Range) ``` -PointerSize returns the size of a pointer in bytes for the target replay -architecture. +MapMemory adds rng as a memory range that needs allocating for replay. #### func (*Builder) Pop @@ -176,7 +154,7 @@ Pop removes the top count values from the top of the stack. #### func (*Builder) Post ```go -func (b *Builder) Post(addr value.Pointer, size uint64, id atom.ID, d PostDecoder) +func (b *Builder) Post(addr value.Pointer, size uint64, p Postback) ``` Post posts size bytes from addr to the decoder d. The decoder d must consume all size bytes before returning; failure to do this will corrupt all subsequent @@ -189,6 +167,15 @@ func (b *Builder) Push(val value.Value) ``` Push pushes val to the top of the stack. +#### func (*Builder) RevertAtom + +```go +func (b *Builder) RevertAtom(err error) +``` +RevertAtom reverts all the instructions since the last call to BeginAtom. Any +postbacks issued since the last call to BeginAtom will be called with the error +err and a nil decoder. + #### func (*Builder) Store ```go @@ -214,6 +201,14 @@ func (b *Builder) String(s string) value.Pointer String returns a pointer to a block of memory in the constant address-space holding the string s. The string will be stored with a null-terminating byte. +#### func (*Builder) Write + +```go +func (b *Builder) Write(rng memory.Range, resourceID binary.ID) +``` +Write fills the memory range in capture address-space rng with the data of +resourceID. + #### type FunctionInfo ```go @@ -227,34 +222,24 @@ type FunctionInfo struct { FunctionInfo holds the information about a function that can be called by the replay virtual-machine. -#### type PostDecoder - -```go -type PostDecoder func(binary.Decoder) (interface{}, error) -``` - -PostDecoder decodes a single atom's postback, returning the postback data or an -error. The PostDecoder must decode all the data that was issued in the Post call -before returning. - #### type Postback ```go -type Postback struct { - ID atom.ID // The associated atom for this Postback. - Data interface{} // The postback data. Nil if Error is non-nil. - Error error // Error raised decoding the postback, or nil if there was no error. -} +type Postback func(d binary.Decoder, err error) error ``` -Postback holds the information for a single atom's postback data. +Postback decodes a single atom's postback, returning and carrying over errors. +The Postback must decode all the data that was issued in the Post call before +returning. If err is nil, then d is the Decoder to the postback data. If d is +nil, then a previous postback failed to decode before decoding could begin for +this postback and err holds the error. #### type ResponseDecoder ```go -type ResponseDecoder func(r io.Reader) <-chan Postback +type ResponseDecoder func(r io.Reader, err error) ``` -ResponseDecoder decodes all postback responses from the replay virtual machine, -writing each to the returned chan. The chan will be closed once all postbacks -have been read, or after the first Postback with a non-nil Error. +ResponseDecoder decodes all postback responses from the replay virtual machine. +If err is nil, then r is the Reader to the sequential postback data. If r is +nil, then the postback data was absent or corrupted and err holds the error. diff --git a/replay/executor/README.md b/replay/executor/README.md index 9bd6e7de8..8c9e41d74 100644 --- a/replay/executor/README.md +++ b/replay/executor/README.md @@ -6,12 +6,6 @@ Package executor contains the Execute function for sending a replay to a device. ## Usage -```go -var ErrNoPostback = errors.New("No postback received") -``` -ErrNoPostback is returned when a data for a postback could not be retrieved. -This can be due to a connection problem or a decode error. - #### func Execute ```go @@ -21,16 +15,9 @@ func Execute( connection io.ReadWriteCloser, database database.Database, logger log.Logger, - handlers PostbackHandlerMap, - byteOrder endian.ByteOrder) error + architecture device.Architecture) error ``` Execute sends the replay payload for execution on the target replay device communicating on connection. decoder will be used for decoding all postback reponses. Once a postback response is decoded, the corresponding handler in the handlers map will be called. - -#### type PostbackHandlerMap - -```go -type PostbackHandlerMap map[atom.ID]func(data interface{}, err error) -``` diff --git a/replay/protocol/README.md b/replay/protocol/README.md index d1281db5a..b65de30e1 100644 --- a/replay/protocol/README.md +++ b/replay/protocol/README.md @@ -57,6 +57,18 @@ type ConnectionType uint8 ConnectionType is sent from the server to the replay system to define the type of connection. +#### func (*ConnectionType) Parse + +```go +func (v *ConnectionType) Parse(s string) error +``` + +#### func (ConnectionType) String + +```go +func (v ConnectionType) String() string +``` + #### type MessageType ```go @@ -65,6 +77,18 @@ type MessageType uint8 MessageType defines the packet type sent from the replay system to the server. +#### func (*MessageType) Parse + +```go +func (v *MessageType) Parse(s string) error +``` + +#### func (MessageType) String + +```go +func (v MessageType) String() string +``` + #### type Opcode ```go @@ -149,6 +173,12 @@ const ( ) ``` +#### func (*Type) Parse + +```go +func (v *Type) Parse(s string) error +``` + #### func (Type) Size ```go @@ -160,6 +190,5 @@ a pointer for the target architecture. #### func (Type) String ```go -func (t Type) String() string +func (v Type) String() string ``` -String returns the human-readable name of the type. diff --git a/replay/value/README.md b/replay/value/README.md index 43178c2b1..c30545403 100644 --- a/replay/value/README.md +++ b/replay/value/README.md @@ -23,9 +23,9 @@ altered before being passed to the protocol. #### func (AbsolutePointer) Get ```go -func (p AbsolutePointer) Get(PointerResolver) (uint64, error) +func (p AbsolutePointer) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the uint64 value of the absolute pointer. +Get returns TypeAbsolutePointer and the uint64 value of the absolute pointer. #### func (AbsolutePointer) IsValid @@ -41,13 +41,6 @@ func (p AbsolutePointer) Offset(offset uint64) Pointer ``` Offset returns the sum of the pointer with offset. -#### func (AbsolutePointer) Type - -```go -func (p AbsolutePointer) Type() protocol.Type -``` -Type returns TypeAbsolutePointer. - #### type Bool ```go @@ -59,16 +52,9 @@ Bool is a Value of type TypeBool. #### func (Bool) Get ```go -func (v Bool) Get(PointerResolver) (uint64, error) -``` -Get returns 1 if the Bool is true, otherwise 0. - -#### func (Bool) Type - -```go -func (v Bool) Type() protocol.Type +func (v Bool) Get(PointerResolver) (protocol.Type, uint64) ``` -Type returns TypeBool. +Get returns TypeBool and 1 if the Bool is true, otherwise 0. #### type ConstantPointer @@ -82,9 +68,10 @@ altered before being passed to the protocol. #### func (ConstantPointer) Get ```go -func (p ConstantPointer) Get(PointerResolver) (uint64, error) +func (p ConstantPointer) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the uint64 value of the pointer in constant address-space. +Get returns TypeConstantPointer and the uint64 value of the pointer in constant +address-space. #### func (ConstantPointer) IsValid @@ -100,13 +87,6 @@ func (p ConstantPointer) Offset(offset uint64) Pointer ``` Offset returns the sum of the pointer with offset. -#### func (ConstantPointer) Type - -```go -func (p ConstantPointer) Type() protocol.Type -``` -Type returns TypeConstantPointer. - #### type F32 ```go @@ -118,17 +98,10 @@ F32 is a Value of type TypeFloat. #### func (F32) Get ```go -func (v F32) Get(PointerResolver) (uint64, error) +func (v F32) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the IEEE 754 representation of the value packed into the low part of -a uint64. - -#### func (F32) Type - -```go -func (v F32) Type() protocol.Type -``` -Type returns TypeFloat. +Get returns TypeFloat and the IEEE 754 representation of the value packed into +the low part of a uint64. #### type F64 @@ -141,16 +114,10 @@ F64 is a Value of type TypeDouble. #### func (F64) Get ```go -func (v F64) Get(PointerResolver) (uint64, error) -``` -Get returns the IEEE 754 representation of the value packed into a uint64. - -#### func (F64) Type - -```go -func (v F64) Type() protocol.Type +func (v F64) Get(PointerResolver) (protocol.Type, uint64) ``` -Type returns TypeDouble. +Get returns TypeDouble and the IEEE 754 representation of the value packed into +a uint64. #### type Pointer @@ -174,59 +141,79 @@ Pointer is a pointer-typed Value. type PointerResolver interface { // TranslateTemporaryPointer returns the temporary address-space pointer ptr // translated to volatile address-space. - TranslateTemporaryPointer(ptr uint64) (uint64, error) + TranslateTemporaryPointer(ptr uint64) uint64 - // TranslateCapturePointer returns the capture-observed pointer - // translated to volatile address-space. - TranslateCapturePointer(ptr uint64) (uint64, error) + // TranslateRemappedPointer returns the capture-observed pointer + // translated to volatile or absolute address-space. + TranslateRemappedPointer(ptr uint64) (protocol.Type, uint64) } ``` PointerResolver is used to translate pointers into the volatile address-space. -#### type S16 +#### type RemappedPointer ```go -type S16 int16 +type RemappedPointer uint64 ``` -S16 is a Value of type TypeInt16. +RemappedPointer is a pointer that was observed at capture time. Pointers of this +type are remapped to an equivalent volatile address-space pointer, or absolute +address-space pointer before being passed to the protocol. -#### func (S16) Get +#### func (RemappedPointer) Get ```go -func (v S16) Get(PointerResolver) (uint64, error) +func (p RemappedPointer) Get(r PointerResolver) (protocol.Type, uint64) ``` -Get returns the value sign-extended to a uint64. +Get returns the pointer type and the pointer translated to either an equivalent +volatile address-space pointer or absolute pointer. -#### func (S16) Type +#### func (RemappedPointer) IsValid ```go -func (v S16) Type() protocol.Type +func (p RemappedPointer) IsValid() bool ``` -Type returns TypeInt16. +IsValid returns true if the pointer considered valid. Currently this is a test +for the pointer being greater than 0x1000 as low addresses are likely to be a +wrong interpretation of the value. This may change in the future. -#### type S32 +#### func (RemappedPointer) Offset ```go -type S32 int32 +func (p RemappedPointer) Offset(offset uint64) Pointer ``` +Offset returns the sum of the pointer with offset. -S32 is a Value of type TypeInt32. +#### type S16 -#### func (S32) Get +```go +type S16 int16 +``` + +S16 is a Value of type TypeInt16. + +#### func (S16) Get ```go -func (v S32) Get(PointerResolver) (uint64, error) +func (v S16) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the value sign-extended to a uint64. +Get returns TypeInt16 and the value sign-extended to a uint64. -#### func (S32) Type +#### type S32 ```go -func (v S32) Type() protocol.Type +type S32 int32 ``` -Type returns TypeInt32. + +S32 is a Value of type TypeInt32. + +#### func (S32) Get + +```go +func (v S32) Get(PointerResolver) (protocol.Type, uint64) +``` +Get returns TypeInt32 and the value sign-extended to a uint64. #### type S64 @@ -239,16 +226,9 @@ S64 is a Value of type TypeInt64. #### func (S64) Get ```go -func (v S64) Get(PointerResolver) (uint64, error) -``` -Get returns the value reinterpreted as a uint64. - -#### func (S64) Type - -```go -func (v S64) Type() protocol.Type +func (v S64) Get(PointerResolver) (protocol.Type, uint64) ``` -Type returns TypeInt64. +Get returns TypeInt64 and the value reinterpreted as a uint64. #### type S8 @@ -261,16 +241,9 @@ S8 is a Value of type TypeInt8. #### func (S8) Get ```go -func (v S8) Get(PointerResolver) (uint64, error) +func (v S8) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the value sign-extended to a uint64. - -#### func (S8) Type - -```go -func (v S8) Type() protocol.Type -``` -Type returns TypeInt8. +Get returns TypeInt8 and the value sign-extended to a uint64. #### type U16 @@ -283,16 +256,9 @@ U16 is a Value of type TypeUint16. #### func (U16) Get ```go -func (v U16) Get(PointerResolver) (uint64, error) -``` -Get returns the value zero-extended to a uint64. - -#### func (U16) Type - -```go -func (v U16) Type() protocol.Type +func (v U16) Get(PointerResolver) (protocol.Type, uint64) ``` -Type returns TypeUint16. +Get returns TypeUint16 and the value zero-extended to a uint64. #### type U32 @@ -305,16 +271,9 @@ U32 is a Value of type TypeUint32. #### func (U32) Get ```go -func (v U32) Get(PointerResolver) (uint64, error) +func (v U32) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the value zero-extended to a uint64. - -#### func (U32) Type - -```go -func (v U32) Type() protocol.Type -``` -Type returns TypeUint32. +Get returns TypeUint32 and the value zero-extended to a uint64. #### type U64 @@ -327,16 +286,9 @@ U64 is a Value of type TypeUint64. #### func (U64) Get ```go -func (v U64) Get(PointerResolver) (uint64, error) +func (v U64) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the value zero-extended to a uint64. - -#### func (U64) Type - -```go -func (v U64) Type() protocol.Type -``` -Type returns TypeUint64. +Get returns TypeUint64 the value zero-extended to a uint64. #### type U8 @@ -349,75 +301,25 @@ U8 is a Value of type TypeUint8. #### func (U8) Get ```go -func (v U8) Get(PointerResolver) (uint64, error) -``` -Get returns the value zero-extended to a uint64. - -#### func (U8) Type - -```go -func (v U8) Type() protocol.Type +func (v U8) Get(PointerResolver) (protocol.Type, uint64) ``` -Type returns TypeUint8. +Get returns TypeUint8 and the value zero-extended to a uint64. #### type Value ```go type Value interface { - // Type returns the virtual-machine type of the Value. - Type() protocol.Type - - // Get returns the bit-representation of the value. For example a boolean - // value would either be 0 or 1, a uint32 value would be zero-extended, a - // float64 would be the IEEE 754 representation reinterpreted as a uint64. - Get(PointerResolver) (uint64, error) + // Get returns the protocol type and the bit-representation of the value. + // For example a boolean value would either be 0 or 1, a uint32 value would be + // zero-extended, a float64 would be the IEEE 754 representation + // reinterpreted as a uint64. + Get(PointerResolver) (protocol.Type, uint64) } ``` Value is the interface for all values to be passed either in opcodes or constant memory to the replay virtual machine. -#### type VolatileCapturePointer - -```go -type VolatileCapturePointer uint64 -``` - -VolatileCapturePointer is a pointer that was observed at capture time. Pointers -of this type are remapped to an equivalent volatile address-space pointer before -being passed to the protocol. - -#### func (VolatileCapturePointer) Get - -```go -func (p VolatileCapturePointer) Get(r PointerResolver) (uint64, error) -``` -Get returns the observed pointer translated to an equivalent volatile -address-space pointer. - -#### func (VolatileCapturePointer) IsValid - -```go -func (p VolatileCapturePointer) IsValid() bool -``` -IsValid returns true if the pointer considered valid. Currently this is a test -for the pointer being greater than 0x10000 as low addresses are likely to be a -wrong interpretation of the value. This may change in the future. - -#### func (VolatileCapturePointer) Offset - -```go -func (p VolatileCapturePointer) Offset(offset uint64) Pointer -``` -Offset returns the sum of the pointer with offset. - -#### func (VolatileCapturePointer) Type - -```go -func (p VolatileCapturePointer) Type() protocol.Type -``` -Type returns TypeVolatilePointer. - #### type VolatilePointer ```go @@ -425,14 +327,15 @@ type VolatilePointer uint64 ``` VolatilePointer is a pointer to the volatile address-space. Unlike -VolatileCapturePointer, there is no remapping. +RemappedPointer, there is no remapping. #### func (VolatilePointer) Get ```go -func (p VolatilePointer) Get(PointerResolver) (uint64, error) +func (p VolatilePointer) Get(PointerResolver) (protocol.Type, uint64) ``` -Get returns the uint64 value of the pointer in volatile address-space. +Get returns TypeVolatilePointer and the uint64 value of the pointer in volatile +address-space. #### func (VolatilePointer) IsValid @@ -448,13 +351,6 @@ func (p VolatilePointer) Offset(offset uint64) Pointer ``` Offset returns the sum of the pointer with offset. -#### func (VolatilePointer) Type - -```go -func (p VolatilePointer) Type() protocol.Type -``` -Type returns TypeVolatilePointer. - #### type VolatileTemporaryPointer ```go @@ -468,10 +364,10 @@ space and its offset is calculated dynamically. #### func (VolatileTemporaryPointer) Get ```go -func (p VolatileTemporaryPointer) Get(r PointerResolver) (uint64, error) +func (p VolatileTemporaryPointer) Get(r PointerResolver) (protocol.Type, uint64) ``` -Get returns the dynamically calculated offset of the temporary pointer within -volatile address-space. +Get returns TypeVolatilePointer and the dynamically calculated offset of the +temporary pointer within volatile address-space. #### func (VolatileTemporaryPointer) IsValid @@ -486,10 +382,3 @@ IsValid returns true. func (p VolatileTemporaryPointer) Offset(offset uint64) Pointer ``` Offset returns the sum of the pointer with offset. - -#### func (VolatileTemporaryPointer) Type - -```go -func (p VolatileTemporaryPointer) Type() protocol.Type -``` -Type returns TypeVolatilePointer. diff --git a/rpc/README.md b/rpc/README.md index e099e4eeb..93ea53d27 100644 --- a/rpc/README.md +++ b/rpc/README.md @@ -18,7 +18,7 @@ formed rpc header. #### func Serve ```go -func Serve(logger log.Logger, r io.Reader, w io.Writer, mtu int, handler Handler) +func Serve(r io.Reader, w io.Writer, mtu int, l log.Logger, handler Handler) ``` Server implements the receiving side of a client server rpc pair. It listens on the reader for calls, and dispatches them to the supplied handler. Any result diff --git a/rpc/test/README.md b/rpc/test/README.md index 782143350..7a5659b00 100644 --- a/rpc/test/README.md +++ b/rpc/test/README.md @@ -22,6 +22,20 @@ type Base interface { Interface Base +#### type BaseArray + +```go +type BaseArray []Base +``` + +Array Baseˢ + +#### func (BaseArray) Format + +```go +func (a BaseArray) Format(f fmt.State, c rune) +``` + #### type Derived ```go @@ -95,10 +109,16 @@ func (i Enum) IsThree() bool func (i Enum) IsTwo() bool ``` +#### func (*Enum) Parse + +```go +func (v *Enum) Parse(s string) error +``` + #### func (Enum) String ```go -func (i Enum) String() string +func (v Enum) String() string ``` #### type ListNode @@ -143,10 +163,10 @@ func (c *ListNode) GetNext() *ListNode #### type ListNodeArray ```go -type ListNodeArray []*ListNode +type ListNodeArray []ListNode ``` -Array ListNodeRefArray +Array ListNodeˢ #### func (ListNodeArray) Format @@ -154,20 +174,34 @@ Array ListNodeRefArray func (a ListNodeArray) Format(f fmt.State, c rune) ``` +#### type ListNodePtrArray + +```go +type ListNodePtrArray []*ListNode +``` + +Array ListNodeᵖˢ + +#### func (ListNodePtrArray) Format + +```go +func (a ListNodePtrArray) Format(f fmt.State, c rune) +``` + #### type RPC ```go type RPC interface { - Add(l log.Logger, a uint32, b uint32) (uint32, error) - EnumToString(l log.Logger, e Enum) (string, error) + Add(a uint32, b uint32, l log.Logger) (uint32, error) + EnumToString(e Enum, l log.Logger) (string, error) GetStruct(l log.Logger) (Struct, error) - SetStruct(l log.Logger, s Struct) error + SetStruct(s Struct, l log.Logger) error GetResource(l log.Logger) (ResourceId, error) - UseResource(l log.Logger, r ResourceId) error - ResolveResource(l log.Logger, r ResourceId) (Resource, error) + UseResource(r ResourceId, l log.Logger) error + ResolveResource(r ResourceId, l log.Logger) (Resource, error) GetSingleListNode(l log.Logger) (*ListNode, error) GetListNodeChain(l log.Logger) (*ListNode, error) - GetListNodeChainArray(l log.Logger) (ListNodeArray, error) + GetListNodeChainArray(l log.Logger) (ListNodePtrArray, error) GetBase(l log.Logger) (Base, error) GetDerived(l log.Logger) (Base, error) } @@ -180,6 +214,23 @@ type RPC interface { func CreateClient(r io.Reader, w io.Writer, mtu int) RPC ``` +#### type Resolver + +```go +type Resolver struct { + Database database.Database +} +``` + + +#### func (Resolver) ResolveResource + +```go +func (r Resolver) ResolveResource(id ResourceId, l log.Logger) (Resource, error) +``` +ResolveResource loads and returns the Resource stored in the resolver's +database, using id. + #### type Resource ```go @@ -203,6 +254,14 @@ func CreateResource( ) *Resource ``` +#### func ResolveResource + +```go +func ResolveResource(id ResourceId, d database.Database, l log.Logger) (*Resource, error) +``` +ResolveResource loads and returns the Resource stored in the database d, using +id. + #### func (*Resource) Class ```go @@ -238,6 +297,13 @@ type ResourceId struct { Handle ResourceId +#### func StoreResource + +```go +func StoreResource(v *Resource, d database.Database, l log.Logger) (ResourceId, error) +``` +StoreResource stores v into the database d, returning the ResourceId. + #### func (*ResourceId) Class ```go diff --git a/service/README.md b/service/README.md index f864358b7..b0da5e7b5 100644 --- a/service/README.md +++ b/service/README.md @@ -44,7 +44,7 @@ func (h ApiId) Valid() bool type ApiIdArray []ApiId ``` -Array ApiIdArray +Array ApiIdˢ #### func (ApiIdArray) Format @@ -97,7 +97,7 @@ func (c *ApiSchema) GetState() StructInfo type ApiSchemaArray []ApiSchema ``` -Array ApiSchemaArray +Array ApiSchemaˢ #### func (ApiSchemaArray) Format @@ -219,7 +219,7 @@ Unpack unpacks the RPC-friendly AtomGroup structure into the atom Group o. type AtomGroupArray []AtomGroup ``` -Array AtomGroupArray +Array AtomGroupˢ #### func (AtomGroupArray) Format @@ -320,7 +320,7 @@ func (c *AtomInfo) GetType() uint16 type AtomInfoArray []AtomInfo ``` -Array AtomInfoArray +Array AtomInfoˢ #### func (AtomInfoArray) Format @@ -434,7 +434,7 @@ func (c *AtomRangeTimer) GetToAtomId() uint64 type AtomRangeTimerArray []AtomRangeTimer ``` -Array AtomRangeTimerArray +Array AtomRangeTimerˢ #### func (AtomRangeTimerArray) Format @@ -468,6 +468,14 @@ func NewAtomStream(list atom.List) (AtomStream, error) ``` NewAtomStream creates a fully-encoded AtomStream from the atom list. +#### func ResolveAtomStream + +```go +func ResolveAtomStream(id AtomStreamId, d database.Database, l log.Logger) (*AtomStream, error) +``` +ResolveAtomStream loads and returns the AtomStream stored in the database d, +using id. + #### func (*AtomStream) Class ```go @@ -498,6 +506,13 @@ type AtomStreamId struct { Handle AtomStreamId +#### func StoreAtomStream + +```go +func StoreAtomStream(v *AtomStream, d database.Database, l log.Logger) (AtomStreamId, error) +``` +StoreAtomStream stores v into the database d, returning the AtomStreamId. + #### func (*AtomStreamId) Class ```go @@ -555,7 +570,7 @@ func (c *AtomTimer) GetNanoseconds() uint64 type AtomTimerArray []AtomTimer ``` -Array AtomTimerArray +Array AtomTimerˢ #### func (AtomTimerArray) Format @@ -582,6 +597,13 @@ func CreateBinary( ) *Binary ``` +#### func ResolveBinary + +```go +func ResolveBinary(id BinaryId, d database.Database, l log.Logger) (*Binary, error) +``` +ResolveBinary loads and returns the Binary stored in the database d, using id. + #### func (*Binary) Class ```go @@ -605,6 +627,13 @@ type BinaryId struct { Handle BinaryId +#### func StoreBinary + +```go +func StoreBinary(v *Binary, d database.Database, l log.Logger) (BinaryId, error) +``` +StoreBinary stores v into the database d, returning the BinaryId. + #### func (*BinaryId) Class ```go @@ -642,6 +671,13 @@ func CreateCapture( ) *Capture ``` +#### func ResolveCapture + +```go +func ResolveCapture(id CaptureId, d database.Database, l log.Logger) (*Capture, error) +``` +ResolveCapture loads and returns the Capture stored in the database d, using id. + #### func (*Capture) Class ```go @@ -683,6 +719,13 @@ type CaptureId struct { Handle CaptureId +#### func StoreCapture + +```go +func StoreCapture(v *Capture, d database.Database, l log.Logger) (CaptureId, error) +``` +StoreCapture stores v into the database d, returning the CaptureId. + #### func (*CaptureId) Class ```go @@ -701,7 +744,7 @@ func (h CaptureId) Valid() bool type CaptureIdArray []CaptureId ``` -Array CaptureIdArray +Array CaptureIdˢ #### func (CaptureIdArray) Format @@ -709,6 +752,20 @@ Array CaptureIdArray func (a CaptureIdArray) Format(f fmt.State, c rune) ``` +#### type ClassArray + +```go +type ClassArray []schema.Class +``` + +Array Classˢ + +#### func (ClassArray) Format + +```go +func (a ClassArray) Format(f fmt.State, c rune) +``` + #### type ClassInfo ```go @@ -716,8 +773,8 @@ type ClassInfo struct { binary.Generate Name string Kind TypeKind - Fields FieldInfoArray - Extends ClassInfoArray + Fields FieldInfoPtrArray + Extends ClassInfoPtrArray } ``` @@ -729,8 +786,8 @@ Class ClassInfo func CreateClassInfo( Name string, Kind TypeKind, - Fields FieldInfoArray, - Extends ClassInfoArray, + Fields FieldInfoPtrArray, + Extends ClassInfoPtrArray, ) *ClassInfo ``` @@ -743,13 +800,13 @@ func (*ClassInfo) Class() binary.Class #### func (*ClassInfo) GetExtends ```go -func (c *ClassInfo) GetExtends() ClassInfoArray +func (c *ClassInfo) GetExtends() ClassInfoPtrArray ``` #### func (*ClassInfo) GetFields ```go -func (c *ClassInfo) GetFields() FieldInfoArray +func (c *ClassInfo) GetFields() FieldInfoPtrArray ``` #### func (*ClassInfo) GetKind @@ -767,10 +824,10 @@ func (c *ClassInfo) GetName() string #### type ClassInfoArray ```go -type ClassInfoArray []*ClassInfo +type ClassInfoArray []ClassInfo ``` -Array ClassInfoRefArray +Array ClassInfoˢ #### func (ClassInfoArray) Format @@ -778,18 +835,49 @@ Array ClassInfoRefArray func (a ClassInfoArray) Format(f fmt.State, c rune) ``` +#### type ClassInfoPtrArray + +```go +type ClassInfoPtrArray []*ClassInfo +``` + +Array ClassInfoᵖˢ + +#### func (ClassInfoPtrArray) Format + +```go +func (a ClassInfoPtrArray) Format(f fmt.State, c rune) +``` + +#### type ClassPtrArray + +```go +type ClassPtrArray []*schema.Class +``` + +Array Classᵖˢ + +#### func (ClassPtrArray) Format + +```go +func (a ClassPtrArray) Format(f fmt.State, c rune) +``` + #### type Device ```go type Device struct { binary.Generate - Name string - Model string - OS string - PointerSize uint8 - PointerAlignment uint8 - MaxMemorySize uint64 - RequiresShaderPatching bool + Name string + Model string + OS string + PointerSize uint8 + PointerAlignment uint8 + MaxMemorySize uint64 + Extensions string + Renderer string + Vendor string + Version string } ``` @@ -805,16 +893,39 @@ func CreateDevice( PointerSize uint8, PointerAlignment uint8, MaxMemorySize uint64, - RequiresShaderPatching bool, + Extensions string, + Renderer string, + Vendor string, + Version string, ) *Device ``` +#### func ResolveDevice + +```go +func ResolveDevice(id DeviceId, d database.Database, l log.Logger) (*Device, error) +``` +ResolveDevice loads and returns the Device stored in the database d, using id. + +#### func (Device) Architecture + +```go +func (d Device) Architecture() device.Architecture +``` +Architecture return's the device's architecture. + #### func (*Device) Class ```go func (*Device) Class() binary.Class ``` +#### func (*Device) GetExtensions + +```go +func (c *Device) GetExtensions() string +``` + #### func (*Device) GetMaxMemorySize ```go @@ -851,10 +962,28 @@ func (c *Device) GetPointerAlignment() uint8 func (c *Device) GetPointerSize() uint8 ``` -#### func (*Device) GetRequiresShaderPatching +#### func (*Device) GetRenderer + +```go +func (c *Device) GetRenderer() string +``` + +#### func (*Device) GetVendor + +```go +func (c *Device) GetVendor() string +``` + +#### func (*Device) GetVersion ```go -func (c *Device) GetRequiresShaderPatching() bool +func (c *Device) GetVersion() string +``` + +#### func (Device) HasExtension + +```go +func (d Device) HasExtension(extension string) bool ``` #### type DeviceId @@ -868,6 +997,13 @@ type DeviceId struct { Handle DeviceId +#### func StoreDevice + +```go +func StoreDevice(v *Device, d database.Database, l log.Logger) (DeviceId, error) +``` +StoreDevice stores v into the database d, returning the DeviceId. + #### func (*DeviceId) Class ```go @@ -886,7 +1022,7 @@ func (h DeviceId) Valid() bool type DeviceIdArray []DeviceId ``` -Array DeviceIdArray +Array DeviceIdˢ #### func (DeviceIdArray) Format @@ -933,13 +1069,19 @@ func (c *EnumEntry) GetName() string func (c *EnumEntry) GetValue() uint32 ``` +#### func (EnumEntry) String + +```go +func (e EnumEntry) String() string +``` + #### type EnumEntryArray ```go type EnumEntryArray []EnumEntry ``` -Array EnumEntryArray +Array EnumEntryˢ #### func (EnumEntryArray) Format @@ -955,7 +1097,7 @@ type EnumInfo struct { Name string Kind TypeKind Entries EnumEntryArray - Extends EnumInfoArray + Extends EnumInfoPtrArray } ``` @@ -968,7 +1110,7 @@ func CreateEnumInfo( Name string, Kind TypeKind, Entries EnumEntryArray, - Extends EnumInfoArray, + Extends EnumInfoPtrArray, ) *EnumInfo ``` @@ -987,7 +1129,7 @@ func (c *EnumInfo) GetEntries() EnumEntryArray #### func (*EnumInfo) GetExtends ```go -func (c *EnumInfo) GetExtends() EnumInfoArray +func (c *EnumInfo) GetExtends() EnumInfoPtrArray ``` #### func (*EnumInfo) GetKind @@ -1005,10 +1147,10 @@ func (c *EnumInfo) GetName() string #### type EnumInfoArray ```go -type EnumInfoArray []*EnumInfo +type EnumInfoArray []EnumInfo ``` -Array EnumInfoRefArray +Array EnumInfoˢ #### func (EnumInfoArray) Format @@ -1016,6 +1158,20 @@ Array EnumInfoRefArray func (a EnumInfoArray) Format(f fmt.State, c rune) ``` +#### type EnumInfoPtrArray + +```go +type EnumInfoPtrArray []*EnumInfo +``` + +Array EnumInfoᵖˢ + +#### func (EnumInfoPtrArray) Format + +```go +func (a EnumInfoPtrArray) Format(f fmt.State, c rune) +``` + #### type FieldInfo ```go @@ -1058,10 +1214,10 @@ func (c *FieldInfo) GetType() TypeInfo #### type FieldInfoArray ```go -type FieldInfoArray []*FieldInfo +type FieldInfoArray []FieldInfo ``` -Array FieldInfoRefArray +Array FieldInfoˢ #### func (FieldInfoArray) Format @@ -1069,6 +1225,20 @@ Array FieldInfoRefArray func (a FieldInfoArray) Format(f fmt.State, c rune) ``` +#### type FieldInfoPtrArray + +```go +type FieldInfoPtrArray []*FieldInfo +``` + +Array FieldInfoᵖˢ + +#### func (FieldInfoPtrArray) Format + +```go +func (a FieldInfoPtrArray) Format(f fmt.State, c rune) +``` + #### type Hierarchy ```go @@ -1088,6 +1258,14 @@ func CreateHierarchy( ) *Hierarchy ``` +#### func ResolveHierarchy + +```go +func ResolveHierarchy(id HierarchyId, d database.Database, l log.Logger) (*Hierarchy, error) +``` +ResolveHierarchy loads and returns the Hierarchy stored in the database d, using +id. + #### func (*Hierarchy) Class ```go @@ -1111,6 +1289,13 @@ type HierarchyId struct { Handle HierarchyId +#### func StoreHierarchy + +```go +func StoreHierarchy(v *Hierarchy, d database.Database, l log.Logger) (HierarchyId, error) +``` +StoreHierarchy stores v into the database d, returning the HierarchyId. + #### func (*HierarchyId) Class ```go @@ -1150,10 +1335,16 @@ func (i ImageFormat) IsFloat32() bool func (i ImageFormat) IsRGBA8() bool ``` +#### func (*ImageFormat) Parse + +```go +func (v *ImageFormat) Parse(s string) error +``` + #### func (ImageFormat) String ```go -func (i ImageFormat) String() string +func (v ImageFormat) String() string ``` #### type ImageInfo @@ -1181,6 +1372,14 @@ func CreateImageInfo( ) *ImageInfo ``` +#### func ResolveImageInfo + +```go +func ResolveImageInfo(id ImageInfoId, d database.Database, l log.Logger) (*ImageInfo, error) +``` +ResolveImageInfo loads and returns the ImageInfo stored in the database d, using +id. + #### func (*ImageInfo) Class ```go @@ -1222,6 +1421,13 @@ type ImageInfoId struct { Handle ImageInfoId +#### func StoreImageInfo + +```go +func StoreImageInfo(v *ImageInfo, d database.Database, l log.Logger) (ImageInfoId, error) +``` +StoreImageInfo stores v into the database d, returning the ImageInfoId. + #### func (*ImageInfoId) Class ```go @@ -1314,6 +1520,14 @@ func CreateMemoryInfo( ) *MemoryInfo ``` +#### func ResolveMemoryInfo + +```go +func ResolveMemoryInfo(id MemoryInfoId, d database.Database, l log.Logger) (*MemoryInfo, error) +``` +ResolveMemoryInfo loads and returns the MemoryInfo stored in the database d, +using id. + #### func (*MemoryInfo) Class ```go @@ -1355,6 +1569,13 @@ type MemoryInfoId struct { Handle MemoryInfoId +#### func StoreMemoryInfo + +```go +func StoreMemoryInfo(v *MemoryInfo, d database.Database, l log.Logger) (MemoryInfoId, error) +``` +StoreMemoryInfo stores v into the database d, returning the MemoryInfoId. + #### func (*MemoryInfoId) Class ```go @@ -1426,7 +1647,7 @@ Unpack unpacks the RPC-friendly MemoryRange structure into the memory Range o. type MemoryRangeArray []MemoryRange ``` -Array MemoryRangeArray +Array MemoryRangeˢ #### func (MemoryRangeArray) Format @@ -1503,7 +1724,7 @@ func (c *ParameterInfo) GetType() TypeInfo type ParameterInfoArray []ParameterInfo ``` -Array ParameterInfoArray +Array ParameterInfoˢ #### func (ParameterInfoArray) Format @@ -1515,26 +1736,27 @@ func (a ParameterInfoArray) Format(f fmt.State, c rune) ```go type RPC interface { - Import(l log.Logger, name string, Data U8Array) (CaptureId, error) + GetSchema(l log.Logger) (ClassPtrArray, error) + Import(name string, Data U8Array, l log.Logger) (CaptureId, error) GetCaptures(l log.Logger) (CaptureIdArray, error) GetDevices(l log.Logger) (DeviceIdArray, error) - GetState(l log.Logger, capture CaptureId, after uint64) (BinaryId, error) - GetHierarchy(l log.Logger, capture CaptureId) (HierarchyId, error) - GetMemoryInfo(l log.Logger, capture CaptureId, after uint64, rng MemoryRange) (MemoryInfoId, error) - GetFramebufferColor(l log.Logger, device DeviceId, capture CaptureId, api ApiId, after uint64, settings RenderSettings) (ImageInfoId, error) - GetFramebufferDepth(l log.Logger, device DeviceId, capture CaptureId, api ApiId, after uint64) (ImageInfoId, error) - GetTimingInfo(l log.Logger, device DeviceId, capture CaptureId, mask TimingMask) (TimingInfoId, error) - PrerenderFramebuffers(l log.Logger, device DeviceId, capture CaptureId, api ApiId, width uint32, height uint32, atomIds U64Array) (BinaryId, error) - ReplaceAtom(l log.Logger, capture CaptureId, atomId uint64, atomType uint16, data Binary) (CaptureId, error) - ResolveAtomStream(l log.Logger, id AtomStreamId) (AtomStream, error) - ResolveBinary(l log.Logger, id BinaryId) (Binary, error) - ResolveCapture(l log.Logger, id CaptureId) (Capture, error) - ResolveDevice(l log.Logger, id DeviceId) (Device, error) - ResolveHierarchy(l log.Logger, id HierarchyId) (Hierarchy, error) - ResolveImageInfo(l log.Logger, id ImageInfoId) (ImageInfo, error) - ResolveMemoryInfo(l log.Logger, id MemoryInfoId) (MemoryInfo, error) - ResolveSchema(l log.Logger, id SchemaId) (Schema, error) - ResolveTimingInfo(l log.Logger, id TimingInfoId) (TimingInfo, error) + GetState(capture CaptureId, after uint64, l log.Logger) (BinaryId, error) + GetHierarchy(capture CaptureId, l log.Logger) (HierarchyId, error) + GetMemoryInfo(capture CaptureId, after uint64, rng MemoryRange, l log.Logger) (MemoryInfoId, error) + GetFramebufferColor(device DeviceId, capture CaptureId, api ApiId, after uint64, settings RenderSettings, l log.Logger) (ImageInfoId, error) + GetFramebufferDepth(device DeviceId, capture CaptureId, api ApiId, after uint64, l log.Logger) (ImageInfoId, error) + GetTimingInfo(device DeviceId, capture CaptureId, mask TimingMask, l log.Logger) (TimingInfoId, error) + PrerenderFramebuffers(device DeviceId, capture CaptureId, api ApiId, width uint32, height uint32, atomIds U64Array, l log.Logger) (BinaryId, error) + ReplaceAtom(capture CaptureId, atomId uint64, atomType uint16, data Binary, l log.Logger) (CaptureId, error) + ResolveAtomStream(id AtomStreamId, l log.Logger) (AtomStream, error) + ResolveBinary(id BinaryId, l log.Logger) (Binary, error) + ResolveCapture(id CaptureId, l log.Logger) (Capture, error) + ResolveDevice(id DeviceId, l log.Logger) (Device, error) + ResolveHierarchy(id HierarchyId, l log.Logger) (Hierarchy, error) + ResolveImageInfo(id ImageInfoId, l log.Logger) (ImageInfo, error) + ResolveMemoryInfo(id MemoryInfoId, l log.Logger) (MemoryInfo, error) + ResolveSchema(id SchemaId, l log.Logger) (Schema, error) + ResolveTimingInfo(id TimingInfoId, l log.Logger) (TimingInfo, error) } ``` @@ -1592,6 +1814,87 @@ func (c *RenderSettings) GetMaxWidth() uint32 func (c *RenderSettings) GetWireframe() bool ``` +#### type Resolver + +```go +type Resolver struct { + Database database.Database +} +``` + + +#### func (Resolver) ResolveAtomStream + +```go +func (r Resolver) ResolveAtomStream(id AtomStreamId, l log.Logger) (AtomStream, error) +``` +ResolveAtomStream loads and returns the AtomStream stored in the resolver's +database, using id. + +#### func (Resolver) ResolveBinary + +```go +func (r Resolver) ResolveBinary(id BinaryId, l log.Logger) (Binary, error) +``` +ResolveBinary loads and returns the Binary stored in the resolver's database, +using id. + +#### func (Resolver) ResolveCapture + +```go +func (r Resolver) ResolveCapture(id CaptureId, l log.Logger) (Capture, error) +``` +ResolveCapture loads and returns the Capture stored in the resolver's database, +using id. + +#### func (Resolver) ResolveDevice + +```go +func (r Resolver) ResolveDevice(id DeviceId, l log.Logger) (Device, error) +``` +ResolveDevice loads and returns the Device stored in the resolver's database, +using id. + +#### func (Resolver) ResolveHierarchy + +```go +func (r Resolver) ResolveHierarchy(id HierarchyId, l log.Logger) (Hierarchy, error) +``` +ResolveHierarchy loads and returns the Hierarchy stored in the resolver's +database, using id. + +#### func (Resolver) ResolveImageInfo + +```go +func (r Resolver) ResolveImageInfo(id ImageInfoId, l log.Logger) (ImageInfo, error) +``` +ResolveImageInfo loads and returns the ImageInfo stored in the resolver's +database, using id. + +#### func (Resolver) ResolveMemoryInfo + +```go +func (r Resolver) ResolveMemoryInfo(id MemoryInfoId, l log.Logger) (MemoryInfo, error) +``` +ResolveMemoryInfo loads and returns the MemoryInfo stored in the resolver's +database, using id. + +#### func (Resolver) ResolveSchema + +```go +func (r Resolver) ResolveSchema(id SchemaId, l log.Logger) (Schema, error) +``` +ResolveSchema loads and returns the Schema stored in the resolver's database, +using id. + +#### func (Resolver) ResolveTimingInfo + +```go +func (r Resolver) ResolveTimingInfo(id TimingInfoId, l log.Logger) (TimingInfo, error) +``` +ResolveTimingInfo loads and returns the TimingInfo stored in the resolver's +database, using id. + #### type Schema ```go @@ -1613,6 +1916,13 @@ func CreateSchema( ) *Schema ``` +#### func ResolveSchema + +```go +func ResolveSchema(id SchemaId, d database.Database, l log.Logger) (*Schema, error) +``` +ResolveSchema loads and returns the Schema stored in the database d, using id. + #### func (*Schema) Class ```go @@ -1642,6 +1952,13 @@ type SchemaId struct { Handle SchemaId +#### func StoreSchema + +```go +func StoreSchema(v *Schema, d database.Database, l log.Logger) (SchemaId, error) +``` +StoreSchema stores v into the database d, returning the SchemaId. + #### func (*SchemaId) Class ```go @@ -1755,7 +2072,7 @@ type StructInfo struct { binary.Generate Name string Kind TypeKind - Fields FieldInfoArray + Fields FieldInfoPtrArray } ``` @@ -1767,7 +2084,7 @@ Class StructInfo func CreateStructInfo( Name string, Kind TypeKind, - Fields FieldInfoArray, + Fields FieldInfoPtrArray, ) *StructInfo ``` @@ -1780,7 +2097,7 @@ func (*StructInfo) Class() binary.Class #### func (*StructInfo) GetFields ```go -func (c *StructInfo) GetFields() FieldInfoArray +func (c *StructInfo) GetFields() FieldInfoPtrArray ``` #### func (*StructInfo) GetKind @@ -1818,6 +2135,14 @@ func CreateTimingInfo( ) *TimingInfo ``` +#### func ResolveTimingInfo + +```go +func ResolveTimingInfo(id TimingInfoId, d database.Database, l log.Logger) (*TimingInfo, error) +``` +ResolveTimingInfo loads and returns the TimingInfo stored in the database d, +using id. + #### func (*TimingInfo) Class ```go @@ -1853,6 +2178,13 @@ type TimingInfoId struct { Handle TimingInfoId +#### func StoreTimingInfo + +```go +func StoreTimingInfo(v *TimingInfo, d database.Database, l log.Logger) (TimingInfoId, error) +``` +StoreTimingInfo stores v into the database d, returning the TimingInfoId. + #### func (*TimingInfoId) Class ```go @@ -1899,10 +2231,16 @@ func (i TimingMask) IsTimingPerDrawCall() bool func (i TimingMask) IsTimingPerFrame() bool ``` +#### func (*TimingMask) Parse + +```go +func (v *TimingMask) Parse(s string) error +``` + #### func (TimingMask) String ```go -func (i TimingMask) String() string +func (v TimingMask) String() string ``` #### type TypeInfo @@ -1917,6 +2255,20 @@ type TypeInfo interface { Interface TypeInfo +#### type TypeInfoArray + +```go +type TypeInfoArray []TypeInfo +``` + +Array TypeInfoˢ + +#### func (TypeInfoArray) Format + +```go +func (a TypeInfoArray) Format(f fmt.State, c rune) +``` + #### type TypeKind ```go @@ -2084,10 +2436,16 @@ func (i TypeKind) IsU64() bool func (i TypeKind) IsU8() bool ``` +#### func (*TypeKind) Parse + +```go +func (v *TypeKind) Parse(s string) error +``` + #### func (TypeKind) String ```go -func (i TypeKind) String() string +func (v TypeKind) String() string ``` #### type U64Array @@ -2096,7 +2454,7 @@ func (i TypeKind) String() string type U64Array []uint64 ``` -Array U64Array +Array U64ˢ #### func (U64Array) Format @@ -2110,7 +2468,7 @@ func (a U64Array) Format(f fmt.State, c rune) type U8Array []uint8 ``` -Array U8Array +Array U8ˢ #### func (U8Array) Format diff --git a/tools/copyright/README.md b/tools/copyright/README.md index aec7bb6b5..c618b15d4 100644 --- a/tools/copyright/README.md +++ b/tools/copyright/README.md @@ -7,6 +7,7 @@ ```go var ( + External = []*regexp.Regexp{} Generated = []*regexp.Regexp{} Normal = []*regexp.Regexp{} ) @@ -18,6 +19,12 @@ var ( func Build(name string, i Info) string ``` +#### func MatchExternal + +```go +func MatchExternal(file []byte) int +``` + #### func MatchGenerated ```go |