import "android.googlesource.com/platform/tools/gpu/gfxapi/test"
Package test is the integration test suite for the api compiler and templates.
func API() gfxapi.API
type BoolArray []bool
func (s BoolArray) Len() int
func (s BoolArray) Range() []bool
type CmdArrayOfFloat struct {
binary.Generate
Result F32Array
}
////////////////////////////////////////////////////////////////////////////// CmdArrayOfFloat //////////////////////////////////////////////////////////////////////////////
func NewCmdArrayOfFloat(
pResult F32Array,
) *CmdArrayOfFloat
func (c *CmdArrayOfFloat) API() gfxapi.API
func (*CmdArrayOfFloat) Class() binary.Class
func (c *CmdArrayOfFloat) Flags() atom.Flags
func (ϟa *CmdArrayOfFloat) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdArrayOfFloat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdArrayOfFloat) String() string
func (c *CmdArrayOfFloat) TypeID() atom.TypeID
type CmdArrayOfFloat_Postback struct {
Result F32Array
}
func (o *CmdArrayOfFloat_Postback) Decode(result_cnt uint64, d binary.Decoder) error
type CmdBool struct {
binary.Generate
Result bool
}
////////////////////////////////////////////////////////////////////////////// CmdBool //////////////////////////////////////////////////////////////////////////////
func NewCmdBool(
pResult bool,
) *CmdBool
func (c *CmdBool) API() gfxapi.API
func (*CmdBool) Class() binary.Class
func (c *CmdBool) Flags() atom.Flags
func (ϟa *CmdBool) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdBool) String() string
func (c *CmdBool) TypeID() atom.TypeID
type CmdBool_Postback struct {
Result bool
}
func (o *CmdBool_Postback) Decode(d binary.Decoder) error
type CmdF32 struct {
binary.Generate
Result float32
}
////////////////////////////////////////////////////////////////////////////// CmdF32 //////////////////////////////////////////////////////////////////////////////
func NewCmdF32(
pResult float32,
) *CmdF32
func (c *CmdF32) API() gfxapi.API
func (*CmdF32) Class() binary.Class
func (c *CmdF32) Flags() atom.Flags
func (ϟa *CmdF32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdF32) String() string
func (c *CmdF32) TypeID() atom.TypeID
type CmdF32_Postback struct {
Result float32
}
func (o *CmdF32_Postback) Decode(d binary.Decoder) error
type CmdF64 struct {
binary.Generate
Result float64
}
////////////////////////////////////////////////////////////////////////////// CmdF64 //////////////////////////////////////////////////////////////////////////////
func NewCmdF64(
pResult float64,
) *CmdF64
func (c *CmdF64) API() gfxapi.API
func (*CmdF64) Class() binary.Class
func (c *CmdF64) Flags() atom.Flags
func (ϟa *CmdF64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdF64) String() string
func (c *CmdF64) TypeID() atom.TypeID
type CmdF64_Postback struct {
Result float64
}
func (o *CmdF64_Postback) Decode(d binary.Decoder) error
type CmdPointer struct {
binary.Generate
Result memory.Pointer
}
////////////////////////////////////////////////////////////////////////////// CmdPointer //////////////////////////////////////////////////////////////////////////////
func NewCmdPointer(
pResult memory.Pointer,
) *CmdPointer
func (c *CmdPointer) API() gfxapi.API
func (*CmdPointer) Class() binary.Class
func (c *CmdPointer) Flags() atom.Flags
func (ϟa *CmdPointer) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdPointer) String() string
func (c *CmdPointer) TypeID() atom.TypeID
type CmdPointer_Postback struct {
Result []byte
}
func (o *CmdPointer_Postback) Decode(result_cnt uint64, d binary.Decoder) error
type CmdS16 struct {
binary.Generate
Result int16
}
////////////////////////////////////////////////////////////////////////////// CmdS16 //////////////////////////////////////////////////////////////////////////////
func NewCmdS16(
pResult int16,
) *CmdS16
func (c *CmdS16) API() gfxapi.API
func (*CmdS16) Class() binary.Class
func (c *CmdS16) Flags() atom.Flags
func (ϟa *CmdS16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdS16) String() string
func (c *CmdS16) TypeID() atom.TypeID
type CmdS16_Postback struct {
Result int16
}
func (o *CmdS16_Postback) Decode(d binary.Decoder) error
type CmdS32 struct {
binary.Generate
Result int32
}
////////////////////////////////////////////////////////////////////////////// CmdS32 //////////////////////////////////////////////////////////////////////////////
func NewCmdS32(
pResult int32,
) *CmdS32
func (c *CmdS32) API() gfxapi.API
func (*CmdS32) Class() binary.Class
func (c *CmdS32) Flags() atom.Flags
func (ϟa *CmdS32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdS32) String() string
func (c *CmdS32) TypeID() atom.TypeID
type CmdS32_Postback struct {
Result int32
}
func (o *CmdS32_Postback) Decode(d binary.Decoder) error
type CmdS64 struct {
binary.Generate
Result int64
}
////////////////////////////////////////////////////////////////////////////// CmdS64 //////////////////////////////////////////////////////////////////////////////
func NewCmdS64(
pResult int64,
) *CmdS64
func (c *CmdS64) API() gfxapi.API
func (*CmdS64) Class() binary.Class
func (c *CmdS64) Flags() atom.Flags
func (ϟa *CmdS64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdS64) String() string
func (c *CmdS64) TypeID() atom.TypeID
type CmdS64_Postback struct {
Result int64
}
func (o *CmdS64_Postback) Decode(d binary.Decoder) error
type CmdS8 struct {
binary.Generate
Result int8
}
////////////////////////////////////////////////////////////////////////////// CmdS8 //////////////////////////////////////////////////////////////////////////////
func NewCmdS8(
pResult int8,
) *CmdS8
func (c *CmdS8) API() gfxapi.API
func (*CmdS8) Class() binary.Class
func (c *CmdS8) Flags() atom.Flags
func (ϟa *CmdS8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdS8) String() string
func (c *CmdS8) TypeID() atom.TypeID
type CmdS8_Postback struct {
Result int8
}
func (o *CmdS8_Postback) Decode(d binary.Decoder) error
type CmdString struct {
binary.Generate
Result string
}
////////////////////////////////////////////////////////////////////////////// CmdString //////////////////////////////////////////////////////////////////////////////
func NewCmdString(
pResult string,
) *CmdString
func (c *CmdString) API() gfxapi.API
func (*CmdString) Class() binary.Class
func (c *CmdString) Flags() atom.Flags
func (ϟa *CmdString) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdString) String() string
func (c *CmdString) TypeID() atom.TypeID
type CmdString_Postback struct {
Result string
}
func (o *CmdString_Postback) Decode(result_cnt uint64, d binary.Decoder) error
type CmdU16 struct {
binary.Generate
Result uint16
}
////////////////////////////////////////////////////////////////////////////// CmdU16 //////////////////////////////////////////////////////////////////////////////
func NewCmdU16(
pResult uint16,
) *CmdU16
func (c *CmdU16) API() gfxapi.API
func (*CmdU16) Class() binary.Class
func (c *CmdU16) Flags() atom.Flags
func (ϟa *CmdU16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdU16) String() string
func (c *CmdU16) TypeID() atom.TypeID
type CmdU16_Postback struct {
Result uint16
}
func (o *CmdU16_Postback) Decode(d binary.Decoder) error
type CmdU32 struct {
binary.Generate
Result uint32
}
////////////////////////////////////////////////////////////////////////////// CmdU32 //////////////////////////////////////////////////////////////////////////////
func NewCmdU32(
pResult uint32,
) *CmdU32
func (c *CmdU32) API() gfxapi.API
func (*CmdU32) Class() binary.Class
func (c *CmdU32) Flags() atom.Flags
func (ϟa *CmdU32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdU32) String() string
func (c *CmdU32) TypeID() atom.TypeID
type CmdU32_Postback struct {
Result uint32
}
func (o *CmdU32_Postback) Decode(d binary.Decoder) error
type CmdU64 struct {
binary.Generate
Result uint64
}
////////////////////////////////////////////////////////////////////////////// CmdU64 //////////////////////////////////////////////////////////////////////////////
func NewCmdU64(
pResult uint64,
) *CmdU64
func (c *CmdU64) API() gfxapi.API
func (*CmdU64) Class() binary.Class
func (c *CmdU64) Flags() atom.Flags
func (ϟa *CmdU64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdU64) String() string
func (c *CmdU64) TypeID() atom.TypeID
type CmdU64_Postback struct {
Result uint64
}
func (o *CmdU64_Postback) Decode(d binary.Decoder) error
type CmdU8 struct {
binary.Generate
Result uint8
}
////////////////////////////////////////////////////////////////////////////// CmdU8 //////////////////////////////////////////////////////////////////////////////
func NewCmdU8(
pResult uint8,
) *CmdU8
func (c *CmdU8) API() gfxapi.API
func (*CmdU8) Class() binary.Class
func (c *CmdU8) Flags() atom.Flags
func (ϟa *CmdU8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdU8) String() string
func (c *CmdU8) TypeID() atom.TypeID
type CmdU8_Postback struct {
Result uint8
}
func (o *CmdU8_Postback) Decode(d binary.Decoder) error
type CmdVoid struct {
binary.Generate
}
////////////////////////////////////////////////////////////////////////////// CmdVoid //////////////////////////////////////////////////////////////////////////////
func NewCmdVoid() *CmdVoid
func (c *CmdVoid) API() gfxapi.API
func (*CmdVoid) Class() binary.Class
func (c *CmdVoid) Flags() atom.Flags
func (ϟa *CmdVoid) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoid) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoid) String() string
func (c *CmdVoid) TypeID() atom.TypeID
type CmdVoid3Arrays struct {
binary.Generate
A S8Array
B StringArray
C BoolArray
}
////////////////////////////////////////////////////////////////////////////// CmdVoid3Arrays //////////////////////////////////////////////////////////////////////////////
func NewCmdVoid3Arrays(
pA S8Array,
pB StringArray,
pC BoolArray,
) *CmdVoid3Arrays
func (c *CmdVoid3Arrays) API() gfxapi.API
func (*CmdVoid3Arrays) Class() binary.Class
func (c *CmdVoid3Arrays) Flags() atom.Flags
func (ϟa *CmdVoid3Arrays) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoid3Arrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoid3Arrays) String() string
func (c *CmdVoid3Arrays) TypeID() atom.TypeID
type CmdVoid3Remapped struct {
binary.Generate
A remapped
B remapped
C remapped
}
////////////////////////////////////////////////////////////////////////////// CmdVoid3Remapped //////////////////////////////////////////////////////////////////////////////
func NewCmdVoid3Remapped(
pA remapped,
pB remapped,
pC remapped,
) *CmdVoid3Remapped
func (c *CmdVoid3Remapped) API() gfxapi.API
func (*CmdVoid3Remapped) Class() binary.Class
func (c *CmdVoid3Remapped) Flags() atom.Flags
func (ϟa *CmdVoid3Remapped) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoid3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoid3Remapped) String() string
func (c *CmdVoid3Remapped) TypeID() atom.TypeID
type CmdVoid3Strings struct {
binary.Generate
A string
B string
C string
}
////////////////////////////////////////////////////////////////////////////// CmdVoid3Strings //////////////////////////////////////////////////////////////////////////////
func NewCmdVoid3Strings(
pA string,
pB string,
pC string,
) *CmdVoid3Strings
func (c *CmdVoid3Strings) API() gfxapi.API
func (*CmdVoid3Strings) Class() binary.Class
func (c *CmdVoid3Strings) Flags() atom.Flags
func (ϟa *CmdVoid3Strings) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoid3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoid3Strings) String() string
func (c *CmdVoid3Strings) TypeID() atom.TypeID
type CmdVoidArrayOfStrings struct {
binary.Generate
A StringArray
}
////////////////////////////////////////////////////////////////////////////// CmdVoidArrayOfStrings //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidArrayOfStrings(
pA StringArray,
) *CmdVoidArrayOfStrings
func (c *CmdVoidArrayOfStrings) API() gfxapi.API
func (*CmdVoidArrayOfStrings) Class() binary.Class
func (c *CmdVoidArrayOfStrings) Flags() atom.Flags
func (ϟa *CmdVoidArrayOfStrings) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidArrayOfStrings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidArrayOfStrings) String() string
func (c *CmdVoidArrayOfStrings) TypeID() atom.TypeID
type CmdVoidBool struct {
binary.Generate
A bool
}
////////////////////////////////////////////////////////////////////////////// CmdVoidBool //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidBool(
pA bool,
) *CmdVoidBool
func (c *CmdVoidBool) API() gfxapi.API
func (*CmdVoidBool) Class() binary.Class
func (c *CmdVoidBool) Flags() atom.Flags
func (ϟa *CmdVoidBool) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidBool) String() string
func (c *CmdVoidBool) TypeID() atom.TypeID
type CmdVoidF32 struct {
binary.Generate
A float32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidF32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidF32(
pA float32,
) *CmdVoidF32
func (c *CmdVoidF32) API() gfxapi.API
func (*CmdVoidF32) Class() binary.Class
func (c *CmdVoidF32) Flags() atom.Flags
func (ϟa *CmdVoidF32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidF32) String() string
func (c *CmdVoidF32) TypeID() atom.TypeID
type CmdVoidF64 struct {
binary.Generate
A float64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidF64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidF64(
pA float64,
) *CmdVoidF64
func (c *CmdVoidF64) API() gfxapi.API
func (*CmdVoidF64) Class() binary.Class
func (c *CmdVoidF64) Flags() atom.Flags
func (ϟa *CmdVoidF64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidF64) String() string
func (c *CmdVoidF64) TypeID() atom.TypeID
type CmdVoidOut3Remapped struct {
binary.Generate
A remapped
B remapped
C remapped
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOut3Remapped //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOut3Remapped(
pA remapped,
pB remapped,
pC remapped,
) *CmdVoidOut3Remapped
func (c *CmdVoidOut3Remapped) API() gfxapi.API
func (*CmdVoidOut3Remapped) Class() binary.Class
func (c *CmdVoidOut3Remapped) Flags() atom.Flags
func (ϟa *CmdVoidOut3Remapped) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOut3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOut3Remapped) String() string
func (c *CmdVoidOut3Remapped) TypeID() atom.TypeID
type CmdVoidOut3Remapped_Postback struct {
A remapped
B remapped
C remapped
}
func (o *CmdVoidOut3Remapped_Postback) Decode(d binary.Decoder) error
type CmdVoidOut3Strings struct {
binary.Generate
A string
B string
C string
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOut3Strings //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOut3Strings(
pA string,
pB string,
pC string,
) *CmdVoidOut3Strings
func (c *CmdVoidOut3Strings) API() gfxapi.API
func (*CmdVoidOut3Strings) Class() binary.Class
func (c *CmdVoidOut3Strings) Flags() atom.Flags
func (ϟa *CmdVoidOut3Strings) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOut3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOut3Strings) String() string
func (c *CmdVoidOut3Strings) TypeID() atom.TypeID
type CmdVoidOut3Strings_Postback struct {
A string
B string
C string
}
func (o *CmdVoidOut3Strings_Postback) Decode(a_cnt uint64,
b_cnt uint64,
c_cnt uint64, d binary.Decoder) error
type CmdVoidOutArrayOfRemapped struct {
binary.Generate
A RemappedArray
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutArrayOfRemapped //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutArrayOfRemapped(
pA RemappedArray,
) *CmdVoidOutArrayOfRemapped
func (c *CmdVoidOutArrayOfRemapped) API() gfxapi.API
func (*CmdVoidOutArrayOfRemapped) Class() binary.Class
func (c *CmdVoidOutArrayOfRemapped) Flags() atom.Flags
func (ϟa *CmdVoidOutArrayOfRemapped) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutArrayOfRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutArrayOfRemapped) String() string
func (c *CmdVoidOutArrayOfRemapped) TypeID() atom.TypeID
type CmdVoidOutArrayOfRemapped_Postback struct {
A RemappedArray
}
func (o *CmdVoidOutArrayOfRemapped_Postback) Decode(a_cnt uint64, d binary.Decoder) error
type CmdVoidOutBool struct {
binary.Generate
A bool
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutBool //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutBool(
pA bool,
) *CmdVoidOutBool
func (c *CmdVoidOutBool) API() gfxapi.API
func (*CmdVoidOutBool) Class() binary.Class
func (c *CmdVoidOutBool) Flags() atom.Flags
func (ϟa *CmdVoidOutBool) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutBool) String() string
func (c *CmdVoidOutBool) TypeID() atom.TypeID
type CmdVoidOutBool_Postback struct {
A bool
}
func (o *CmdVoidOutBool_Postback) Decode(d binary.Decoder) error
type CmdVoidOutF32 struct {
binary.Generate
A float32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutF32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutF32(
pA float32,
) *CmdVoidOutF32
func (c *CmdVoidOutF32) API() gfxapi.API
func (*CmdVoidOutF32) Class() binary.Class
func (c *CmdVoidOutF32) Flags() atom.Flags
func (ϟa *CmdVoidOutF32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutF32) String() string
func (c *CmdVoidOutF32) TypeID() atom.TypeID
type CmdVoidOutF32_Postback struct {
A float32
}
func (o *CmdVoidOutF32_Postback) Decode(d binary.Decoder) error
type CmdVoidOutF64 struct {
binary.Generate
A float64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutF64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutF64(
pA float64,
) *CmdVoidOutF64
func (c *CmdVoidOutF64) API() gfxapi.API
func (*CmdVoidOutF64) Class() binary.Class
func (c *CmdVoidOutF64) Flags() atom.Flags
func (ϟa *CmdVoidOutF64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutF64) String() string
func (c *CmdVoidOutF64) TypeID() atom.TypeID
type CmdVoidOutF64_Postback struct {
A float64
}
func (o *CmdVoidOutF64_Postback) Decode(d binary.Decoder) error
type CmdVoidOutFixedSizeBuffer struct {
binary.Generate
A memory.Pointer
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutFixedSizeBuffer //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutFixedSizeBuffer(
pA memory.Pointer,
) *CmdVoidOutFixedSizeBuffer
func (c *CmdVoidOutFixedSizeBuffer) API() gfxapi.API
func (*CmdVoidOutFixedSizeBuffer) Class() binary.Class
func (c *CmdVoidOutFixedSizeBuffer) Flags() atom.Flags
func (ϟa *CmdVoidOutFixedSizeBuffer) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutFixedSizeBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutFixedSizeBuffer) String() string
func (c *CmdVoidOutFixedSizeBuffer) TypeID() atom.TypeID
type CmdVoidOutFixedSizeBuffer_Postback struct {
A []byte
}
func (o *CmdVoidOutFixedSizeBuffer_Postback) Decode(a_cnt uint64, d binary.Decoder) error
type CmdVoidOutS16 struct {
binary.Generate
A int16
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutS16 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutS16(
pA int16,
) *CmdVoidOutS16
func (c *CmdVoidOutS16) API() gfxapi.API
func (*CmdVoidOutS16) Class() binary.Class
func (c *CmdVoidOutS16) Flags() atom.Flags
func (ϟa *CmdVoidOutS16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutS16) String() string
func (c *CmdVoidOutS16) TypeID() atom.TypeID
type CmdVoidOutS16_Postback struct {
A int16
}
func (o *CmdVoidOutS16_Postback) Decode(d binary.Decoder) error
type CmdVoidOutS32 struct {
binary.Generate
A int32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutS32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutS32(
pA int32,
) *CmdVoidOutS32
func (c *CmdVoidOutS32) API() gfxapi.API
func (*CmdVoidOutS32) Class() binary.Class
func (c *CmdVoidOutS32) Flags() atom.Flags
func (ϟa *CmdVoidOutS32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutS32) String() string
func (c *CmdVoidOutS32) TypeID() atom.TypeID
type CmdVoidOutS32_Postback struct {
A int32
}
func (o *CmdVoidOutS32_Postback) Decode(d binary.Decoder) error
type CmdVoidOutS64 struct {
binary.Generate
A int64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutS64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutS64(
pA int64,
) *CmdVoidOutS64
func (c *CmdVoidOutS64) API() gfxapi.API
func (*CmdVoidOutS64) Class() binary.Class
func (c *CmdVoidOutS64) Flags() atom.Flags
func (ϟa *CmdVoidOutS64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutS64) String() string
func (c *CmdVoidOutS64) TypeID() atom.TypeID
type CmdVoidOutS64_Postback struct {
A int64
}
func (o *CmdVoidOutS64_Postback) Decode(d binary.Decoder) error
type CmdVoidOutS8 struct {
binary.Generate
A int8
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutS8 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutS8(
pA int8,
) *CmdVoidOutS8
func (c *CmdVoidOutS8) API() gfxapi.API
func (*CmdVoidOutS8) Class() binary.Class
func (c *CmdVoidOutS8) Flags() atom.Flags
func (ϟa *CmdVoidOutS8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutS8) String() string
func (c *CmdVoidOutS8) TypeID() atom.TypeID
type CmdVoidOutS8_Postback struct {
A int8
}
func (o *CmdVoidOutS8_Postback) Decode(d binary.Decoder) error
type CmdVoidOutString struct {
binary.Generate
A string
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutString //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutString(
pA string,
) *CmdVoidOutString
func (c *CmdVoidOutString) API() gfxapi.API
func (*CmdVoidOutString) Class() binary.Class
func (c *CmdVoidOutString) Flags() atom.Flags
func (ϟa *CmdVoidOutString) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutString) String() string
func (c *CmdVoidOutString) TypeID() atom.TypeID
type CmdVoidOutString_Postback struct {
A string
}
func (o *CmdVoidOutString_Postback) Decode(a_cnt uint64, d binary.Decoder) error
type CmdVoidOutU16 struct {
binary.Generate
A uint16
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutU16 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutU16(
pA uint16,
) *CmdVoidOutU16
func (c *CmdVoidOutU16) API() gfxapi.API
func (*CmdVoidOutU16) Class() binary.Class
func (c *CmdVoidOutU16) Flags() atom.Flags
func (ϟa *CmdVoidOutU16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutU16) String() string
func (c *CmdVoidOutU16) TypeID() atom.TypeID
type CmdVoidOutU16_Postback struct {
A uint16
}
func (o *CmdVoidOutU16_Postback) Decode(d binary.Decoder) error
type CmdVoidOutU32 struct {
binary.Generate
A uint32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutU32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutU32(
pA uint32,
) *CmdVoidOutU32
func (c *CmdVoidOutU32) API() gfxapi.API
func (*CmdVoidOutU32) Class() binary.Class
func (c *CmdVoidOutU32) Flags() atom.Flags
func (ϟa *CmdVoidOutU32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutU32) String() string
func (c *CmdVoidOutU32) TypeID() atom.TypeID
type CmdVoidOutU32_Postback struct {
A uint32
}
func (o *CmdVoidOutU32_Postback) Decode(d binary.Decoder) error
type CmdVoidOutU64 struct {
binary.Generate
A uint64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutU64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutU64(
pA uint64,
) *CmdVoidOutU64
func (c *CmdVoidOutU64) API() gfxapi.API
func (*CmdVoidOutU64) Class() binary.Class
func (c *CmdVoidOutU64) Flags() atom.Flags
func (ϟa *CmdVoidOutU64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutU64) String() string
func (c *CmdVoidOutU64) TypeID() atom.TypeID
type CmdVoidOutU64_Postback struct {
A uint64
}
func (o *CmdVoidOutU64_Postback) Decode(d binary.Decoder) error
type CmdVoidOutU8 struct {
binary.Generate
A uint8
}
////////////////////////////////////////////////////////////////////////////// CmdVoidOutU8 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidOutU8(
pA uint8,
) *CmdVoidOutU8
func (c *CmdVoidOutU8) API() gfxapi.API
func (*CmdVoidOutU8) Class() binary.Class
func (c *CmdVoidOutU8) Flags() atom.Flags
func (ϟa *CmdVoidOutU8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidOutU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidOutU8) String() string
func (c *CmdVoidOutU8) TypeID() atom.TypeID
type CmdVoidOutU8_Postback struct {
A uint8
}
func (o *CmdVoidOutU8_Postback) Decode(d binary.Decoder) error
type CmdVoidS16 struct {
binary.Generate
A int16
}
////////////////////////////////////////////////////////////////////////////// CmdVoidS16 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidS16(
pA int16,
) *CmdVoidS16
func (c *CmdVoidS16) API() gfxapi.API
func (*CmdVoidS16) Class() binary.Class
func (c *CmdVoidS16) Flags() atom.Flags
func (ϟa *CmdVoidS16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidS16) String() string
func (c *CmdVoidS16) TypeID() atom.TypeID
type CmdVoidS32 struct {
binary.Generate
A int32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidS32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidS32(
pA int32,
) *CmdVoidS32
func (c *CmdVoidS32) API() gfxapi.API
func (*CmdVoidS32) Class() binary.Class
func (c *CmdVoidS32) Flags() atom.Flags
func (ϟa *CmdVoidS32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidS32) String() string
func (c *CmdVoidS32) TypeID() atom.TypeID
type CmdVoidS64 struct {
binary.Generate
A int64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidS64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidS64(
pA int64,
) *CmdVoidS64
func (c *CmdVoidS64) API() gfxapi.API
func (*CmdVoidS64) Class() binary.Class
func (c *CmdVoidS64) Flags() atom.Flags
func (ϟa *CmdVoidS64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidS64) String() string
func (c *CmdVoidS64) TypeID() atom.TypeID
type CmdVoidS8 struct {
binary.Generate
A int8
}
////////////////////////////////////////////////////////////////////////////// CmdVoidS8 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidS8(
pA int8,
) *CmdVoidS8
func (c *CmdVoidS8) API() gfxapi.API
func (*CmdVoidS8) Class() binary.Class
func (c *CmdVoidS8) Flags() atom.Flags
func (ϟa *CmdVoidS8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidS8) String() string
func (c *CmdVoidS8) TypeID() atom.TypeID
type CmdVoidString struct {
binary.Generate
A string
}
////////////////////////////////////////////////////////////////////////////// CmdVoidString //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidString(
pA string,
) *CmdVoidString
func (c *CmdVoidString) API() gfxapi.API
func (*CmdVoidString) Class() binary.Class
func (c *CmdVoidString) Flags() atom.Flags
func (ϟa *CmdVoidString) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidString) String() string
func (c *CmdVoidString) TypeID() atom.TypeID
type CmdVoidU16 struct {
binary.Generate
A uint16
}
////////////////////////////////////////////////////////////////////////////// CmdVoidU16 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidU16(
pA uint16,
) *CmdVoidU16
func (c *CmdVoidU16) API() gfxapi.API
func (*CmdVoidU16) Class() binary.Class
func (c *CmdVoidU16) Flags() atom.Flags
func (ϟa *CmdVoidU16) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidU16) String() string
func (c *CmdVoidU16) TypeID() atom.TypeID
type CmdVoidU32 struct {
binary.Generate
A uint32
}
////////////////////////////////////////////////////////////////////////////// CmdVoidU32 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidU32(
pA uint32,
) *CmdVoidU32
func (c *CmdVoidU32) API() gfxapi.API
func (*CmdVoidU32) Class() binary.Class
func (c *CmdVoidU32) Flags() atom.Flags
func (ϟa *CmdVoidU32) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidU32) String() string
func (c *CmdVoidU32) TypeID() atom.TypeID
type CmdVoidU64 struct {
binary.Generate
A uint64
}
////////////////////////////////////////////////////////////////////////////// CmdVoidU64 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidU64(
pA uint64,
) *CmdVoidU64
func (c *CmdVoidU64) API() gfxapi.API
func (*CmdVoidU64) Class() binary.Class
func (c *CmdVoidU64) Flags() atom.Flags
func (ϟa *CmdVoidU64) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidU64) String() string
func (c *CmdVoidU64) TypeID() atom.TypeID
type CmdVoidU8 struct {
binary.Generate
A uint8
}
////////////////////////////////////////////////////////////////////////////// CmdVoidU8 //////////////////////////////////////////////////////////////////////////////
func NewCmdVoidU8(
pA uint8,
) *CmdVoidU8
func (c *CmdVoidU8) API() gfxapi.API
func (*CmdVoidU8) Class() binary.Class
func (c *CmdVoidU8) Flags() atom.Flags
func (ϟa *CmdVoidU8) Mutate(ϟs *gfxapi.State) error
func (ϟa *CmdVoidU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)
func (c *CmdVoidU8) String() string
func (c *CmdVoidU8) TypeID() atom.TypeID
type F32Array []float32
func (s F32Array) Len() int
func (s F32Array) Range() []float32
type Globals struct {
binary.Generate
}
////////////////////////////////////////////////////////////////////////////// Globals //////////////////////////////////////////////////////////////////////////////
func (*Globals) Class() binary.Class
func (g *Globals) Init()
type RemappedArray []remapped
func (s RemappedArray) Len() int
func (s RemappedArray) Range() []remapped
type S8Array []int8
func (s S8Array) Len() int
func (s S8Array) Range() []int8
type State struct {
Globals
ValidateOutput bool
}
type StringArray []string
func (s StringArray) Len() int
func (s StringArray) Range() []string