tree: 1a2417fffdc8833d3f44891e4b7ab47fa5b8cc69 [path history] [tgz]
  1. api.go
  2. gfxapi_test.api
  3. gfxapi_test_import.api
  4. gfxapi_test_include.api
  5. intrinsics_test.go
  6. README.md
  7. replay_writer.go
  8. replay_writer_test.go
  9. schema.go
  10. state_mutator.go
  11. test.go
  12. test_binary.go
gfxapi/test/README.md

test


import "android.googlesource.com/platform/tools/gpu/gfxapi/test"

Package test is the integration test suite for the api compiler and templates.

Usage

func API

func API() gfxapi.API

type BoolArray

type BoolArray []bool

func (BoolArray) Len

func (s BoolArray) Len() int

func (BoolArray) Range

func (s BoolArray) Range() []bool

type CmdArrayOfFloat

type CmdArrayOfFloat struct {
	binary.Generate
	Result F32Array
}

////////////////////////////////////////////////////////////////////////////// CmdArrayOfFloat //////////////////////////////////////////////////////////////////////////////

func NewCmdArrayOfFloat

func NewCmdArrayOfFloat(
	pResult F32Array,
) *CmdArrayOfFloat

func (*CmdArrayOfFloat) API

func (c *CmdArrayOfFloat) API() gfxapi.API

func (*CmdArrayOfFloat) Class

func (*CmdArrayOfFloat) Class() binary.Class

func (*CmdArrayOfFloat) Flags

func (c *CmdArrayOfFloat) Flags() atom.Flags

func (*CmdArrayOfFloat) Mutate

func (ϟa *CmdArrayOfFloat) Mutate(ϟs *gfxapi.State) error

func (*CmdArrayOfFloat) Replay

func (ϟa *CmdArrayOfFloat) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdArrayOfFloat) String

func (c *CmdArrayOfFloat) String() string

func (*CmdArrayOfFloat) TypeID

func (c *CmdArrayOfFloat) TypeID() atom.TypeID

type CmdArrayOfFloat_Postback

type CmdArrayOfFloat_Postback struct {
	Result F32Array
}

func (*CmdArrayOfFloat_Postback) Decode

func (o *CmdArrayOfFloat_Postback) Decode(result_cnt uint64, d binary.Decoder) error

type CmdBool

type CmdBool struct {
	binary.Generate
	Result bool
}

////////////////////////////////////////////////////////////////////////////// CmdBool //////////////////////////////////////////////////////////////////////////////

func NewCmdBool

func NewCmdBool(
	pResult bool,
) *CmdBool

func (*CmdBool) API

func (c *CmdBool) API() gfxapi.API

func (*CmdBool) Class

func (*CmdBool) Class() binary.Class

func (*CmdBool) Flags

func (c *CmdBool) Flags() atom.Flags

func (*CmdBool) Mutate

func (ϟa *CmdBool) Mutate(ϟs *gfxapi.State) error

func (*CmdBool) Replay

func (ϟa *CmdBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdBool) String

func (c *CmdBool) String() string

func (*CmdBool) TypeID

func (c *CmdBool) TypeID() atom.TypeID

type CmdBool_Postback

type CmdBool_Postback struct {
	Result bool
}

func (*CmdBool_Postback) Decode

func (o *CmdBool_Postback) Decode(d binary.Decoder) error

type CmdF32

type CmdF32 struct {
	binary.Generate
	Result float32
}

////////////////////////////////////////////////////////////////////////////// CmdF32 //////////////////////////////////////////////////////////////////////////////

func NewCmdF32

func NewCmdF32(
	pResult float32,
) *CmdF32

func (*CmdF32) API

func (c *CmdF32) API() gfxapi.API

func (*CmdF32) Class

func (*CmdF32) Class() binary.Class

func (*CmdF32) Flags

func (c *CmdF32) Flags() atom.Flags

func (*CmdF32) Mutate

func (ϟa *CmdF32) Mutate(ϟs *gfxapi.State) error

func (*CmdF32) Replay

func (ϟa *CmdF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdF32) String

func (c *CmdF32) String() string

func (*CmdF32) TypeID

func (c *CmdF32) TypeID() atom.TypeID

type CmdF32_Postback

type CmdF32_Postback struct {
	Result float32
}

func (*CmdF32_Postback) Decode

func (o *CmdF32_Postback) Decode(d binary.Decoder) error

type CmdF64

type CmdF64 struct {
	binary.Generate
	Result float64
}

////////////////////////////////////////////////////////////////////////////// CmdF64 //////////////////////////////////////////////////////////////////////////////

func NewCmdF64

func NewCmdF64(
	pResult float64,
) *CmdF64

func (*CmdF64) API

func (c *CmdF64) API() gfxapi.API

func (*CmdF64) Class

func (*CmdF64) Class() binary.Class

func (*CmdF64) Flags

func (c *CmdF64) Flags() atom.Flags

func (*CmdF64) Mutate

func (ϟa *CmdF64) Mutate(ϟs *gfxapi.State) error

func (*CmdF64) Replay

func (ϟa *CmdF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdF64) String

func (c *CmdF64) String() string

func (*CmdF64) TypeID

func (c *CmdF64) TypeID() atom.TypeID

type CmdF64_Postback

type CmdF64_Postback struct {
	Result float64
}

func (*CmdF64_Postback) Decode

func (o *CmdF64_Postback) Decode(d binary.Decoder) error

type CmdPointer

type CmdPointer struct {
	binary.Generate
	Result memory.Pointer
}

////////////////////////////////////////////////////////////////////////////// CmdPointer //////////////////////////////////////////////////////////////////////////////

func NewCmdPointer

func NewCmdPointer(
	pResult memory.Pointer,
) *CmdPointer

func (*CmdPointer) API

func (c *CmdPointer) API() gfxapi.API

func (*CmdPointer) Class

func (*CmdPointer) Class() binary.Class

func (*CmdPointer) Flags

func (c *CmdPointer) Flags() atom.Flags

func (*CmdPointer) Mutate

func (ϟa *CmdPointer) Mutate(ϟs *gfxapi.State) error

func (*CmdPointer) Replay

func (ϟa *CmdPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdPointer) String

func (c *CmdPointer) String() string

func (*CmdPointer) TypeID

func (c *CmdPointer) TypeID() atom.TypeID

type CmdPointer_Postback

type CmdPointer_Postback struct {
	Result []byte
}

func (*CmdPointer_Postback) Decode

func (o *CmdPointer_Postback) Decode(result_cnt uint64, d binary.Decoder) error

type CmdS16

type CmdS16 struct {
	binary.Generate
	Result int16
}

////////////////////////////////////////////////////////////////////////////// CmdS16 //////////////////////////////////////////////////////////////////////////////

func NewCmdS16

func NewCmdS16(
	pResult int16,
) *CmdS16

func (*CmdS16) API

func (c *CmdS16) API() gfxapi.API

func (*CmdS16) Class

func (*CmdS16) Class() binary.Class

func (*CmdS16) Flags

func (c *CmdS16) Flags() atom.Flags

func (*CmdS16) Mutate

func (ϟa *CmdS16) Mutate(ϟs *gfxapi.State) error

func (*CmdS16) Replay

func (ϟa *CmdS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdS16) String

func (c *CmdS16) String() string

func (*CmdS16) TypeID

func (c *CmdS16) TypeID() atom.TypeID

type CmdS16_Postback

type CmdS16_Postback struct {
	Result int16
}

func (*CmdS16_Postback) Decode

func (o *CmdS16_Postback) Decode(d binary.Decoder) error

type CmdS32

type CmdS32 struct {
	binary.Generate
	Result int32
}

////////////////////////////////////////////////////////////////////////////// CmdS32 //////////////////////////////////////////////////////////////////////////////

func NewCmdS32

func NewCmdS32(
	pResult int32,
) *CmdS32

func (*CmdS32) API

func (c *CmdS32) API() gfxapi.API

func (*CmdS32) Class

func (*CmdS32) Class() binary.Class

func (*CmdS32) Flags

func (c *CmdS32) Flags() atom.Flags

func (*CmdS32) Mutate

func (ϟa *CmdS32) Mutate(ϟs *gfxapi.State) error

func (*CmdS32) Replay

func (ϟa *CmdS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdS32) String

func (c *CmdS32) String() string

func (*CmdS32) TypeID

func (c *CmdS32) TypeID() atom.TypeID

type CmdS32_Postback

type CmdS32_Postback struct {
	Result int32
}

func (*CmdS32_Postback) Decode

func (o *CmdS32_Postback) Decode(d binary.Decoder) error

type CmdS64

type CmdS64 struct {
	binary.Generate
	Result int64
}

////////////////////////////////////////////////////////////////////////////// CmdS64 //////////////////////////////////////////////////////////////////////////////

func NewCmdS64

func NewCmdS64(
	pResult int64,
) *CmdS64

func (*CmdS64) API

func (c *CmdS64) API() gfxapi.API

func (*CmdS64) Class

func (*CmdS64) Class() binary.Class

func (*CmdS64) Flags

func (c *CmdS64) Flags() atom.Flags

func (*CmdS64) Mutate

func (ϟa *CmdS64) Mutate(ϟs *gfxapi.State) error

func (*CmdS64) Replay

func (ϟa *CmdS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdS64) String

func (c *CmdS64) String() string

func (*CmdS64) TypeID

func (c *CmdS64) TypeID() atom.TypeID

type CmdS64_Postback

type CmdS64_Postback struct {
	Result int64
}

func (*CmdS64_Postback) Decode

func (o *CmdS64_Postback) Decode(d binary.Decoder) error

type CmdS8

type CmdS8 struct {
	binary.Generate
	Result int8
}

////////////////////////////////////////////////////////////////////////////// CmdS8 //////////////////////////////////////////////////////////////////////////////

func NewCmdS8

func NewCmdS8(
	pResult int8,
) *CmdS8

func (*CmdS8) API

func (c *CmdS8) API() gfxapi.API

func (*CmdS8) Class

func (*CmdS8) Class() binary.Class

func (*CmdS8) Flags

func (c *CmdS8) Flags() atom.Flags

func (*CmdS8) Mutate

func (ϟa *CmdS8) Mutate(ϟs *gfxapi.State) error

func (*CmdS8) Replay

func (ϟa *CmdS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdS8) String

func (c *CmdS8) String() string

func (*CmdS8) TypeID

func (c *CmdS8) TypeID() atom.TypeID

type CmdS8_Postback

type CmdS8_Postback struct {
	Result int8
}

func (*CmdS8_Postback) Decode

func (o *CmdS8_Postback) Decode(d binary.Decoder) error

type CmdString

type CmdString struct {
	binary.Generate
	Result string
}

////////////////////////////////////////////////////////////////////////////// CmdString //////////////////////////////////////////////////////////////////////////////

func NewCmdString

func NewCmdString(
	pResult string,
) *CmdString

func (*CmdString) API

func (c *CmdString) API() gfxapi.API

func (*CmdString) Class

func (*CmdString) Class() binary.Class

func (*CmdString) Flags

func (c *CmdString) Flags() atom.Flags

func (*CmdString) Mutate

func (ϟa *CmdString) Mutate(ϟs *gfxapi.State) error

func (*CmdString) Replay

func (ϟa *CmdString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdString) String

func (c *CmdString) String() string

func (*CmdString) TypeID

func (c *CmdString) TypeID() atom.TypeID

type CmdString_Postback

type CmdString_Postback struct {
	Result string
}

func (*CmdString_Postback) Decode

func (o *CmdString_Postback) Decode(result_cnt uint64, d binary.Decoder) error

type CmdU16

type CmdU16 struct {
	binary.Generate
	Result uint16
}

////////////////////////////////////////////////////////////////////////////// CmdU16 //////////////////////////////////////////////////////////////////////////////

func NewCmdU16

func NewCmdU16(
	pResult uint16,
) *CmdU16

func (*CmdU16) API

func (c *CmdU16) API() gfxapi.API

func (*CmdU16) Class

func (*CmdU16) Class() binary.Class

func (*CmdU16) Flags

func (c *CmdU16) Flags() atom.Flags

func (*CmdU16) Mutate

func (ϟa *CmdU16) Mutate(ϟs *gfxapi.State) error

func (*CmdU16) Replay

func (ϟa *CmdU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdU16) String

func (c *CmdU16) String() string

func (*CmdU16) TypeID

func (c *CmdU16) TypeID() atom.TypeID

type CmdU16_Postback

type CmdU16_Postback struct {
	Result uint16
}

func (*CmdU16_Postback) Decode

func (o *CmdU16_Postback) Decode(d binary.Decoder) error

type CmdU32

type CmdU32 struct {
	binary.Generate
	Result uint32
}

////////////////////////////////////////////////////////////////////////////// CmdU32 //////////////////////////////////////////////////////////////////////////////

func NewCmdU32

func NewCmdU32(
	pResult uint32,
) *CmdU32

func (*CmdU32) API

func (c *CmdU32) API() gfxapi.API

func (*CmdU32) Class

func (*CmdU32) Class() binary.Class

func (*CmdU32) Flags

func (c *CmdU32) Flags() atom.Flags

func (*CmdU32) Mutate

func (ϟa *CmdU32) Mutate(ϟs *gfxapi.State) error

func (*CmdU32) Replay

func (ϟa *CmdU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdU32) String

func (c *CmdU32) String() string

func (*CmdU32) TypeID

func (c *CmdU32) TypeID() atom.TypeID

type CmdU32_Postback

type CmdU32_Postback struct {
	Result uint32
}

func (*CmdU32_Postback) Decode

func (o *CmdU32_Postback) Decode(d binary.Decoder) error

type CmdU64

type CmdU64 struct {
	binary.Generate
	Result uint64
}

////////////////////////////////////////////////////////////////////////////// CmdU64 //////////////////////////////////////////////////////////////////////////////

func NewCmdU64

func NewCmdU64(
	pResult uint64,
) *CmdU64

func (*CmdU64) API

func (c *CmdU64) API() gfxapi.API

func (*CmdU64) Class

func (*CmdU64) Class() binary.Class

func (*CmdU64) Flags

func (c *CmdU64) Flags() atom.Flags

func (*CmdU64) Mutate

func (ϟa *CmdU64) Mutate(ϟs *gfxapi.State) error

func (*CmdU64) Replay

func (ϟa *CmdU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdU64) String

func (c *CmdU64) String() string

func (*CmdU64) TypeID

func (c *CmdU64) TypeID() atom.TypeID

type CmdU64_Postback

type CmdU64_Postback struct {
	Result uint64
}

func (*CmdU64_Postback) Decode

func (o *CmdU64_Postback) Decode(d binary.Decoder) error

type CmdU8

type CmdU8 struct {
	binary.Generate
	Result uint8
}

////////////////////////////////////////////////////////////////////////////// CmdU8 //////////////////////////////////////////////////////////////////////////////

func NewCmdU8

func NewCmdU8(
	pResult uint8,
) *CmdU8

func (*CmdU8) API

func (c *CmdU8) API() gfxapi.API

func (*CmdU8) Class

func (*CmdU8) Class() binary.Class

func (*CmdU8) Flags

func (c *CmdU8) Flags() atom.Flags

func (*CmdU8) Mutate

func (ϟa *CmdU8) Mutate(ϟs *gfxapi.State) error

func (*CmdU8) Replay

func (ϟa *CmdU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdU8) String

func (c *CmdU8) String() string

func (*CmdU8) TypeID

func (c *CmdU8) TypeID() atom.TypeID

type CmdU8_Postback

type CmdU8_Postback struct {
	Result uint8
}

func (*CmdU8_Postback) Decode

func (o *CmdU8_Postback) Decode(d binary.Decoder) error

type CmdVoid

type CmdVoid struct {
	binary.Generate
}

////////////////////////////////////////////////////////////////////////////// CmdVoid //////////////////////////////////////////////////////////////////////////////

func NewCmdVoid

func NewCmdVoid() *CmdVoid

func (*CmdVoid) API

func (c *CmdVoid) API() gfxapi.API

func (*CmdVoid) Class

func (*CmdVoid) Class() binary.Class

func (*CmdVoid) Flags

func (c *CmdVoid) Flags() atom.Flags

func (*CmdVoid) Mutate

func (ϟa *CmdVoid) Mutate(ϟs *gfxapi.State) error

func (*CmdVoid) Replay

func (ϟa *CmdVoid) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoid) String

func (c *CmdVoid) String() string

func (*CmdVoid) TypeID

func (c *CmdVoid) TypeID() atom.TypeID

type CmdVoid3Arrays

type CmdVoid3Arrays struct {
	binary.Generate
	A S8Array
	B StringArray
	C BoolArray
}

////////////////////////////////////////////////////////////////////////////// CmdVoid3Arrays //////////////////////////////////////////////////////////////////////////////

func NewCmdVoid3Arrays

func NewCmdVoid3Arrays(
	pA S8Array,
	pB StringArray,
	pC BoolArray,
) *CmdVoid3Arrays

func (*CmdVoid3Arrays) API

func (c *CmdVoid3Arrays) API() gfxapi.API

func (*CmdVoid3Arrays) Class

func (*CmdVoid3Arrays) Class() binary.Class

func (*CmdVoid3Arrays) Flags

func (c *CmdVoid3Arrays) Flags() atom.Flags

func (*CmdVoid3Arrays) Mutate

func (ϟa *CmdVoid3Arrays) Mutate(ϟs *gfxapi.State) error

func (*CmdVoid3Arrays) Replay

func (ϟa *CmdVoid3Arrays) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoid3Arrays) String

func (c *CmdVoid3Arrays) String() string

func (*CmdVoid3Arrays) TypeID

func (c *CmdVoid3Arrays) TypeID() atom.TypeID

type CmdVoid3Remapped

type CmdVoid3Remapped struct {
	binary.Generate
	A remapped
	B remapped
	C remapped
}

////////////////////////////////////////////////////////////////////////////// CmdVoid3Remapped //////////////////////////////////////////////////////////////////////////////

func NewCmdVoid3Remapped

func NewCmdVoid3Remapped(
	pA remapped,
	pB remapped,
	pC remapped,
) *CmdVoid3Remapped

func (*CmdVoid3Remapped) API

func (c *CmdVoid3Remapped) API() gfxapi.API

func (*CmdVoid3Remapped) Class

func (*CmdVoid3Remapped) Class() binary.Class

func (*CmdVoid3Remapped) Flags

func (c *CmdVoid3Remapped) Flags() atom.Flags

func (*CmdVoid3Remapped) Mutate

func (ϟa *CmdVoid3Remapped) Mutate(ϟs *gfxapi.State) error

func (*CmdVoid3Remapped) Replay

func (ϟa *CmdVoid3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoid3Remapped) String

func (c *CmdVoid3Remapped) String() string

func (*CmdVoid3Remapped) TypeID

func (c *CmdVoid3Remapped) TypeID() atom.TypeID

type CmdVoid3Strings

type CmdVoid3Strings struct {
	binary.Generate
	A string
	B string
	C string
}

////////////////////////////////////////////////////////////////////////////// CmdVoid3Strings //////////////////////////////////////////////////////////////////////////////

func NewCmdVoid3Strings

func NewCmdVoid3Strings(
	pA string,
	pB string,
	pC string,
) *CmdVoid3Strings

func (*CmdVoid3Strings) API

func (c *CmdVoid3Strings) API() gfxapi.API

func (*CmdVoid3Strings) Class

func (*CmdVoid3Strings) Class() binary.Class

func (*CmdVoid3Strings) Flags

func (c *CmdVoid3Strings) Flags() atom.Flags

func (*CmdVoid3Strings) Mutate

func (ϟa *CmdVoid3Strings) Mutate(ϟs *gfxapi.State) error

func (*CmdVoid3Strings) Replay

func (ϟa *CmdVoid3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoid3Strings) String

func (c *CmdVoid3Strings) String() string

func (*CmdVoid3Strings) TypeID

func (c *CmdVoid3Strings) TypeID() atom.TypeID

type CmdVoidArrayOfStrings

type CmdVoidArrayOfStrings struct {
	binary.Generate
	A StringArray
}

////////////////////////////////////////////////////////////////////////////// CmdVoidArrayOfStrings //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidArrayOfStrings

func NewCmdVoidArrayOfStrings(
	pA StringArray,
) *CmdVoidArrayOfStrings

func (*CmdVoidArrayOfStrings) API

func (c *CmdVoidArrayOfStrings) API() gfxapi.API

func (*CmdVoidArrayOfStrings) Class

func (*CmdVoidArrayOfStrings) Class() binary.Class

func (*CmdVoidArrayOfStrings) Flags

func (c *CmdVoidArrayOfStrings) Flags() atom.Flags

func (*CmdVoidArrayOfStrings) Mutate

func (ϟa *CmdVoidArrayOfStrings) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidArrayOfStrings) Replay

func (ϟa *CmdVoidArrayOfStrings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidArrayOfStrings) String

func (c *CmdVoidArrayOfStrings) String() string

func (*CmdVoidArrayOfStrings) TypeID

func (c *CmdVoidArrayOfStrings) TypeID() atom.TypeID

type CmdVoidBool

type CmdVoidBool struct {
	binary.Generate
	A bool
}

////////////////////////////////////////////////////////////////////////////// CmdVoidBool //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidBool

func NewCmdVoidBool(
	pA bool,
) *CmdVoidBool

func (*CmdVoidBool) API

func (c *CmdVoidBool) API() gfxapi.API

func (*CmdVoidBool) Class

func (*CmdVoidBool) Class() binary.Class

func (*CmdVoidBool) Flags

func (c *CmdVoidBool) Flags() atom.Flags

func (*CmdVoidBool) Mutate

func (ϟa *CmdVoidBool) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidBool) Replay

func (ϟa *CmdVoidBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidBool) String

func (c *CmdVoidBool) String() string

func (*CmdVoidBool) TypeID

func (c *CmdVoidBool) TypeID() atom.TypeID

type CmdVoidF32

type CmdVoidF32 struct {
	binary.Generate
	A float32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidF32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidF32

func NewCmdVoidF32(
	pA float32,
) *CmdVoidF32

func (*CmdVoidF32) API

func (c *CmdVoidF32) API() gfxapi.API

func (*CmdVoidF32) Class

func (*CmdVoidF32) Class() binary.Class

func (*CmdVoidF32) Flags

func (c *CmdVoidF32) Flags() atom.Flags

func (*CmdVoidF32) Mutate

func (ϟa *CmdVoidF32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidF32) Replay

func (ϟa *CmdVoidF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidF32) String

func (c *CmdVoidF32) String() string

func (*CmdVoidF32) TypeID

func (c *CmdVoidF32) TypeID() atom.TypeID

type CmdVoidF64

type CmdVoidF64 struct {
	binary.Generate
	A float64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidF64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidF64

func NewCmdVoidF64(
	pA float64,
) *CmdVoidF64

func (*CmdVoidF64) API

func (c *CmdVoidF64) API() gfxapi.API

func (*CmdVoidF64) Class

func (*CmdVoidF64) Class() binary.Class

func (*CmdVoidF64) Flags

func (c *CmdVoidF64) Flags() atom.Flags

func (*CmdVoidF64) Mutate

func (ϟa *CmdVoidF64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidF64) Replay

func (ϟa *CmdVoidF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidF64) String

func (c *CmdVoidF64) String() string

func (*CmdVoidF64) TypeID

func (c *CmdVoidF64) TypeID() atom.TypeID

type CmdVoidOut3Remapped

type CmdVoidOut3Remapped struct {
	binary.Generate
	A remapped
	B remapped
	C remapped
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOut3Remapped //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOut3Remapped

func NewCmdVoidOut3Remapped(
	pA remapped,
	pB remapped,
	pC remapped,
) *CmdVoidOut3Remapped

func (*CmdVoidOut3Remapped) API

func (c *CmdVoidOut3Remapped) API() gfxapi.API

func (*CmdVoidOut3Remapped) Class

func (*CmdVoidOut3Remapped) Class() binary.Class

func (*CmdVoidOut3Remapped) Flags

func (c *CmdVoidOut3Remapped) Flags() atom.Flags

func (*CmdVoidOut3Remapped) Mutate

func (ϟa *CmdVoidOut3Remapped) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOut3Remapped) Replay

func (ϟa *CmdVoidOut3Remapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOut3Remapped) String

func (c *CmdVoidOut3Remapped) String() string

func (*CmdVoidOut3Remapped) TypeID

func (c *CmdVoidOut3Remapped) TypeID() atom.TypeID

type CmdVoidOut3Remapped_Postback

type CmdVoidOut3Remapped_Postback struct {
	A remapped
	B remapped
	C remapped
}

func (*CmdVoidOut3Remapped_Postback) Decode

func (o *CmdVoidOut3Remapped_Postback) Decode(d binary.Decoder) error

type CmdVoidOut3Strings

type CmdVoidOut3Strings struct {
	binary.Generate
	A string
	B string
	C string
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOut3Strings //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOut3Strings

func NewCmdVoidOut3Strings(
	pA string,
	pB string,
	pC string,
) *CmdVoidOut3Strings

func (*CmdVoidOut3Strings) API

func (c *CmdVoidOut3Strings) API() gfxapi.API

func (*CmdVoidOut3Strings) Class

func (*CmdVoidOut3Strings) Class() binary.Class

func (*CmdVoidOut3Strings) Flags

func (c *CmdVoidOut3Strings) Flags() atom.Flags

func (*CmdVoidOut3Strings) Mutate

func (ϟa *CmdVoidOut3Strings) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOut3Strings) Replay

func (ϟa *CmdVoidOut3Strings) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOut3Strings) String

func (c *CmdVoidOut3Strings) String() string

func (*CmdVoidOut3Strings) TypeID

func (c *CmdVoidOut3Strings) TypeID() atom.TypeID

type CmdVoidOut3Strings_Postback

type CmdVoidOut3Strings_Postback struct {
	A string
	B string
	C string
}

func (*CmdVoidOut3Strings_Postback) Decode

func (o *CmdVoidOut3Strings_Postback) Decode(a_cnt uint64,
	b_cnt uint64,
	c_cnt uint64, d binary.Decoder) error

type CmdVoidOutArrayOfRemapped

type CmdVoidOutArrayOfRemapped struct {
	binary.Generate
	A RemappedArray
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutArrayOfRemapped //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutArrayOfRemapped

func NewCmdVoidOutArrayOfRemapped(
	pA RemappedArray,
) *CmdVoidOutArrayOfRemapped

func (*CmdVoidOutArrayOfRemapped) API

func (c *CmdVoidOutArrayOfRemapped) API() gfxapi.API

func (*CmdVoidOutArrayOfRemapped) Class

func (*CmdVoidOutArrayOfRemapped) Class() binary.Class

func (*CmdVoidOutArrayOfRemapped) Flags

func (c *CmdVoidOutArrayOfRemapped) Flags() atom.Flags

func (*CmdVoidOutArrayOfRemapped) Mutate

func (ϟa *CmdVoidOutArrayOfRemapped) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutArrayOfRemapped) Replay

func (ϟa *CmdVoidOutArrayOfRemapped) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutArrayOfRemapped) String

func (c *CmdVoidOutArrayOfRemapped) String() string

func (*CmdVoidOutArrayOfRemapped) TypeID

func (c *CmdVoidOutArrayOfRemapped) TypeID() atom.TypeID

type CmdVoidOutArrayOfRemapped_Postback

type CmdVoidOutArrayOfRemapped_Postback struct {
	A RemappedArray
}

func (*CmdVoidOutArrayOfRemapped_Postback) Decode

func (o *CmdVoidOutArrayOfRemapped_Postback) Decode(a_cnt uint64, d binary.Decoder) error

type CmdVoidOutBool

type CmdVoidOutBool struct {
	binary.Generate
	A bool
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutBool //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutBool

func NewCmdVoidOutBool(
	pA bool,
) *CmdVoidOutBool

func (*CmdVoidOutBool) API

func (c *CmdVoidOutBool) API() gfxapi.API

func (*CmdVoidOutBool) Class

func (*CmdVoidOutBool) Class() binary.Class

func (*CmdVoidOutBool) Flags

func (c *CmdVoidOutBool) Flags() atom.Flags

func (*CmdVoidOutBool) Mutate

func (ϟa *CmdVoidOutBool) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutBool) Replay

func (ϟa *CmdVoidOutBool) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutBool) String

func (c *CmdVoidOutBool) String() string

func (*CmdVoidOutBool) TypeID

func (c *CmdVoidOutBool) TypeID() atom.TypeID

type CmdVoidOutBool_Postback

type CmdVoidOutBool_Postback struct {
	A bool
}

func (*CmdVoidOutBool_Postback) Decode

func (o *CmdVoidOutBool_Postback) Decode(d binary.Decoder) error

type CmdVoidOutF32

type CmdVoidOutF32 struct {
	binary.Generate
	A float32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutF32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutF32

func NewCmdVoidOutF32(
	pA float32,
) *CmdVoidOutF32

func (*CmdVoidOutF32) API

func (c *CmdVoidOutF32) API() gfxapi.API

func (*CmdVoidOutF32) Class

func (*CmdVoidOutF32) Class() binary.Class

func (*CmdVoidOutF32) Flags

func (c *CmdVoidOutF32) Flags() atom.Flags

func (*CmdVoidOutF32) Mutate

func (ϟa *CmdVoidOutF32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutF32) Replay

func (ϟa *CmdVoidOutF32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutF32) String

func (c *CmdVoidOutF32) String() string

func (*CmdVoidOutF32) TypeID

func (c *CmdVoidOutF32) TypeID() atom.TypeID

type CmdVoidOutF32_Postback

type CmdVoidOutF32_Postback struct {
	A float32
}

func (*CmdVoidOutF32_Postback) Decode

func (o *CmdVoidOutF32_Postback) Decode(d binary.Decoder) error

type CmdVoidOutF64

type CmdVoidOutF64 struct {
	binary.Generate
	A float64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutF64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutF64

func NewCmdVoidOutF64(
	pA float64,
) *CmdVoidOutF64

func (*CmdVoidOutF64) API

func (c *CmdVoidOutF64) API() gfxapi.API

func (*CmdVoidOutF64) Class

func (*CmdVoidOutF64) Class() binary.Class

func (*CmdVoidOutF64) Flags

func (c *CmdVoidOutF64) Flags() atom.Flags

func (*CmdVoidOutF64) Mutate

func (ϟa *CmdVoidOutF64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutF64) Replay

func (ϟa *CmdVoidOutF64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutF64) String

func (c *CmdVoidOutF64) String() string

func (*CmdVoidOutF64) TypeID

func (c *CmdVoidOutF64) TypeID() atom.TypeID

type CmdVoidOutF64_Postback

type CmdVoidOutF64_Postback struct {
	A float64
}

func (*CmdVoidOutF64_Postback) Decode

func (o *CmdVoidOutF64_Postback) Decode(d binary.Decoder) error

type CmdVoidOutFixedSizeBuffer

type CmdVoidOutFixedSizeBuffer struct {
	binary.Generate
	A memory.Pointer
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutFixedSizeBuffer //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutFixedSizeBuffer

func NewCmdVoidOutFixedSizeBuffer(
	pA memory.Pointer,
) *CmdVoidOutFixedSizeBuffer

func (*CmdVoidOutFixedSizeBuffer) API

func (c *CmdVoidOutFixedSizeBuffer) API() gfxapi.API

func (*CmdVoidOutFixedSizeBuffer) Class

func (*CmdVoidOutFixedSizeBuffer) Class() binary.Class

func (*CmdVoidOutFixedSizeBuffer) Flags

func (c *CmdVoidOutFixedSizeBuffer) Flags() atom.Flags

func (*CmdVoidOutFixedSizeBuffer) Mutate

func (ϟa *CmdVoidOutFixedSizeBuffer) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutFixedSizeBuffer) Replay

func (ϟa *CmdVoidOutFixedSizeBuffer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutFixedSizeBuffer) String

func (c *CmdVoidOutFixedSizeBuffer) String() string

func (*CmdVoidOutFixedSizeBuffer) TypeID

func (c *CmdVoidOutFixedSizeBuffer) TypeID() atom.TypeID

type CmdVoidOutFixedSizeBuffer_Postback

type CmdVoidOutFixedSizeBuffer_Postback struct {
	A []byte
}

func (*CmdVoidOutFixedSizeBuffer_Postback) Decode

func (o *CmdVoidOutFixedSizeBuffer_Postback) Decode(a_cnt uint64, d binary.Decoder) error

type CmdVoidOutS16

type CmdVoidOutS16 struct {
	binary.Generate
	A int16
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutS16 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutS16

func NewCmdVoidOutS16(
	pA int16,
) *CmdVoidOutS16

func (*CmdVoidOutS16) API

func (c *CmdVoidOutS16) API() gfxapi.API

func (*CmdVoidOutS16) Class

func (*CmdVoidOutS16) Class() binary.Class

func (*CmdVoidOutS16) Flags

func (c *CmdVoidOutS16) Flags() atom.Flags

func (*CmdVoidOutS16) Mutate

func (ϟa *CmdVoidOutS16) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutS16) Replay

func (ϟa *CmdVoidOutS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutS16) String

func (c *CmdVoidOutS16) String() string

func (*CmdVoidOutS16) TypeID

func (c *CmdVoidOutS16) TypeID() atom.TypeID

type CmdVoidOutS16_Postback

type CmdVoidOutS16_Postback struct {
	A int16
}

func (*CmdVoidOutS16_Postback) Decode

func (o *CmdVoidOutS16_Postback) Decode(d binary.Decoder) error

type CmdVoidOutS32

type CmdVoidOutS32 struct {
	binary.Generate
	A int32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutS32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutS32

func NewCmdVoidOutS32(
	pA int32,
) *CmdVoidOutS32

func (*CmdVoidOutS32) API

func (c *CmdVoidOutS32) API() gfxapi.API

func (*CmdVoidOutS32) Class

func (*CmdVoidOutS32) Class() binary.Class

func (*CmdVoidOutS32) Flags

func (c *CmdVoidOutS32) Flags() atom.Flags

func (*CmdVoidOutS32) Mutate

func (ϟa *CmdVoidOutS32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutS32) Replay

func (ϟa *CmdVoidOutS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutS32) String

func (c *CmdVoidOutS32) String() string

func (*CmdVoidOutS32) TypeID

func (c *CmdVoidOutS32) TypeID() atom.TypeID

type CmdVoidOutS32_Postback

type CmdVoidOutS32_Postback struct {
	A int32
}

func (*CmdVoidOutS32_Postback) Decode

func (o *CmdVoidOutS32_Postback) Decode(d binary.Decoder) error

type CmdVoidOutS64

type CmdVoidOutS64 struct {
	binary.Generate
	A int64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutS64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutS64

func NewCmdVoidOutS64(
	pA int64,
) *CmdVoidOutS64

func (*CmdVoidOutS64) API

func (c *CmdVoidOutS64) API() gfxapi.API

func (*CmdVoidOutS64) Class

func (*CmdVoidOutS64) Class() binary.Class

func (*CmdVoidOutS64) Flags

func (c *CmdVoidOutS64) Flags() atom.Flags

func (*CmdVoidOutS64) Mutate

func (ϟa *CmdVoidOutS64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutS64) Replay

func (ϟa *CmdVoidOutS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutS64) String

func (c *CmdVoidOutS64) String() string

func (*CmdVoidOutS64) TypeID

func (c *CmdVoidOutS64) TypeID() atom.TypeID

type CmdVoidOutS64_Postback

type CmdVoidOutS64_Postback struct {
	A int64
}

func (*CmdVoidOutS64_Postback) Decode

func (o *CmdVoidOutS64_Postback) Decode(d binary.Decoder) error

type CmdVoidOutS8

type CmdVoidOutS8 struct {
	binary.Generate
	A int8
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutS8 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutS8

func NewCmdVoidOutS8(
	pA int8,
) *CmdVoidOutS8

func (*CmdVoidOutS8) API

func (c *CmdVoidOutS8) API() gfxapi.API

func (*CmdVoidOutS8) Class

func (*CmdVoidOutS8) Class() binary.Class

func (*CmdVoidOutS8) Flags

func (c *CmdVoidOutS8) Flags() atom.Flags

func (*CmdVoidOutS8) Mutate

func (ϟa *CmdVoidOutS8) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutS8) Replay

func (ϟa *CmdVoidOutS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutS8) String

func (c *CmdVoidOutS8) String() string

func (*CmdVoidOutS8) TypeID

func (c *CmdVoidOutS8) TypeID() atom.TypeID

type CmdVoidOutS8_Postback

type CmdVoidOutS8_Postback struct {
	A int8
}

func (*CmdVoidOutS8_Postback) Decode

func (o *CmdVoidOutS8_Postback) Decode(d binary.Decoder) error

type CmdVoidOutString

type CmdVoidOutString struct {
	binary.Generate
	A string
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutString //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutString

func NewCmdVoidOutString(
	pA string,
) *CmdVoidOutString

func (*CmdVoidOutString) API

func (c *CmdVoidOutString) API() gfxapi.API

func (*CmdVoidOutString) Class

func (*CmdVoidOutString) Class() binary.Class

func (*CmdVoidOutString) Flags

func (c *CmdVoidOutString) Flags() atom.Flags

func (*CmdVoidOutString) Mutate

func (ϟa *CmdVoidOutString) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutString) Replay

func (ϟa *CmdVoidOutString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutString) String

func (c *CmdVoidOutString) String() string

func (*CmdVoidOutString) TypeID

func (c *CmdVoidOutString) TypeID() atom.TypeID

type CmdVoidOutString_Postback

type CmdVoidOutString_Postback struct {
	A string
}

func (*CmdVoidOutString_Postback) Decode

func (o *CmdVoidOutString_Postback) Decode(a_cnt uint64, d binary.Decoder) error

type CmdVoidOutU16

type CmdVoidOutU16 struct {
	binary.Generate
	A uint16
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutU16 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutU16

func NewCmdVoidOutU16(
	pA uint16,
) *CmdVoidOutU16

func (*CmdVoidOutU16) API

func (c *CmdVoidOutU16) API() gfxapi.API

func (*CmdVoidOutU16) Class

func (*CmdVoidOutU16) Class() binary.Class

func (*CmdVoidOutU16) Flags

func (c *CmdVoidOutU16) Flags() atom.Flags

func (*CmdVoidOutU16) Mutate

func (ϟa *CmdVoidOutU16) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutU16) Replay

func (ϟa *CmdVoidOutU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutU16) String

func (c *CmdVoidOutU16) String() string

func (*CmdVoidOutU16) TypeID

func (c *CmdVoidOutU16) TypeID() atom.TypeID

type CmdVoidOutU16_Postback

type CmdVoidOutU16_Postback struct {
	A uint16
}

func (*CmdVoidOutU16_Postback) Decode

func (o *CmdVoidOutU16_Postback) Decode(d binary.Decoder) error

type CmdVoidOutU32

type CmdVoidOutU32 struct {
	binary.Generate
	A uint32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutU32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutU32

func NewCmdVoidOutU32(
	pA uint32,
) *CmdVoidOutU32

func (*CmdVoidOutU32) API

func (c *CmdVoidOutU32) API() gfxapi.API

func (*CmdVoidOutU32) Class

func (*CmdVoidOutU32) Class() binary.Class

func (*CmdVoidOutU32) Flags

func (c *CmdVoidOutU32) Flags() atom.Flags

func (*CmdVoidOutU32) Mutate

func (ϟa *CmdVoidOutU32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutU32) Replay

func (ϟa *CmdVoidOutU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutU32) String

func (c *CmdVoidOutU32) String() string

func (*CmdVoidOutU32) TypeID

func (c *CmdVoidOutU32) TypeID() atom.TypeID

type CmdVoidOutU32_Postback

type CmdVoidOutU32_Postback struct {
	A uint32
}

func (*CmdVoidOutU32_Postback) Decode

func (o *CmdVoidOutU32_Postback) Decode(d binary.Decoder) error

type CmdVoidOutU64

type CmdVoidOutU64 struct {
	binary.Generate
	A uint64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutU64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutU64

func NewCmdVoidOutU64(
	pA uint64,
) *CmdVoidOutU64

func (*CmdVoidOutU64) API

func (c *CmdVoidOutU64) API() gfxapi.API

func (*CmdVoidOutU64) Class

func (*CmdVoidOutU64) Class() binary.Class

func (*CmdVoidOutU64) Flags

func (c *CmdVoidOutU64) Flags() atom.Flags

func (*CmdVoidOutU64) Mutate

func (ϟa *CmdVoidOutU64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutU64) Replay

func (ϟa *CmdVoidOutU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutU64) String

func (c *CmdVoidOutU64) String() string

func (*CmdVoidOutU64) TypeID

func (c *CmdVoidOutU64) TypeID() atom.TypeID

type CmdVoidOutU64_Postback

type CmdVoidOutU64_Postback struct {
	A uint64
}

func (*CmdVoidOutU64_Postback) Decode

func (o *CmdVoidOutU64_Postback) Decode(d binary.Decoder) error

type CmdVoidOutU8

type CmdVoidOutU8 struct {
	binary.Generate
	A uint8
}

////////////////////////////////////////////////////////////////////////////// CmdVoidOutU8 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidOutU8

func NewCmdVoidOutU8(
	pA uint8,
) *CmdVoidOutU8

func (*CmdVoidOutU8) API

func (c *CmdVoidOutU8) API() gfxapi.API

func (*CmdVoidOutU8) Class

func (*CmdVoidOutU8) Class() binary.Class

func (*CmdVoidOutU8) Flags

func (c *CmdVoidOutU8) Flags() atom.Flags

func (*CmdVoidOutU8) Mutate

func (ϟa *CmdVoidOutU8) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidOutU8) Replay

func (ϟa *CmdVoidOutU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidOutU8) String

func (c *CmdVoidOutU8) String() string

func (*CmdVoidOutU8) TypeID

func (c *CmdVoidOutU8) TypeID() atom.TypeID

type CmdVoidOutU8_Postback

type CmdVoidOutU8_Postback struct {
	A uint8
}

func (*CmdVoidOutU8_Postback) Decode

func (o *CmdVoidOutU8_Postback) Decode(d binary.Decoder) error

type CmdVoidS16

type CmdVoidS16 struct {
	binary.Generate
	A int16
}

////////////////////////////////////////////////////////////////////////////// CmdVoidS16 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidS16

func NewCmdVoidS16(
	pA int16,
) *CmdVoidS16

func (*CmdVoidS16) API

func (c *CmdVoidS16) API() gfxapi.API

func (*CmdVoidS16) Class

func (*CmdVoidS16) Class() binary.Class

func (*CmdVoidS16) Flags

func (c *CmdVoidS16) Flags() atom.Flags

func (*CmdVoidS16) Mutate

func (ϟa *CmdVoidS16) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidS16) Replay

func (ϟa *CmdVoidS16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidS16) String

func (c *CmdVoidS16) String() string

func (*CmdVoidS16) TypeID

func (c *CmdVoidS16) TypeID() atom.TypeID

type CmdVoidS32

type CmdVoidS32 struct {
	binary.Generate
	A int32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidS32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidS32

func NewCmdVoidS32(
	pA int32,
) *CmdVoidS32

func (*CmdVoidS32) API

func (c *CmdVoidS32) API() gfxapi.API

func (*CmdVoidS32) Class

func (*CmdVoidS32) Class() binary.Class

func (*CmdVoidS32) Flags

func (c *CmdVoidS32) Flags() atom.Flags

func (*CmdVoidS32) Mutate

func (ϟa *CmdVoidS32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidS32) Replay

func (ϟa *CmdVoidS32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidS32) String

func (c *CmdVoidS32) String() string

func (*CmdVoidS32) TypeID

func (c *CmdVoidS32) TypeID() atom.TypeID

type CmdVoidS64

type CmdVoidS64 struct {
	binary.Generate
	A int64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidS64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidS64

func NewCmdVoidS64(
	pA int64,
) *CmdVoidS64

func (*CmdVoidS64) API

func (c *CmdVoidS64) API() gfxapi.API

func (*CmdVoidS64) Class

func (*CmdVoidS64) Class() binary.Class

func (*CmdVoidS64) Flags

func (c *CmdVoidS64) Flags() atom.Flags

func (*CmdVoidS64) Mutate

func (ϟa *CmdVoidS64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidS64) Replay

func (ϟa *CmdVoidS64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidS64) String

func (c *CmdVoidS64) String() string

func (*CmdVoidS64) TypeID

func (c *CmdVoidS64) TypeID() atom.TypeID

type CmdVoidS8

type CmdVoidS8 struct {
	binary.Generate
	A int8
}

////////////////////////////////////////////////////////////////////////////// CmdVoidS8 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidS8

func NewCmdVoidS8(
	pA int8,
) *CmdVoidS8

func (*CmdVoidS8) API

func (c *CmdVoidS8) API() gfxapi.API

func (*CmdVoidS8) Class

func (*CmdVoidS8) Class() binary.Class

func (*CmdVoidS8) Flags

func (c *CmdVoidS8) Flags() atom.Flags

func (*CmdVoidS8) Mutate

func (ϟa *CmdVoidS8) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidS8) Replay

func (ϟa *CmdVoidS8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidS8) String

func (c *CmdVoidS8) String() string

func (*CmdVoidS8) TypeID

func (c *CmdVoidS8) TypeID() atom.TypeID

type CmdVoidString

type CmdVoidString struct {
	binary.Generate
	A string
}

////////////////////////////////////////////////////////////////////////////// CmdVoidString //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidString

func NewCmdVoidString(
	pA string,
) *CmdVoidString

func (*CmdVoidString) API

func (c *CmdVoidString) API() gfxapi.API

func (*CmdVoidString) Class

func (*CmdVoidString) Class() binary.Class

func (*CmdVoidString) Flags

func (c *CmdVoidString) Flags() atom.Flags

func (*CmdVoidString) Mutate

func (ϟa *CmdVoidString) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidString) Replay

func (ϟa *CmdVoidString) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidString) String

func (c *CmdVoidString) String() string

func (*CmdVoidString) TypeID

func (c *CmdVoidString) TypeID() atom.TypeID

type CmdVoidU16

type CmdVoidU16 struct {
	binary.Generate
	A uint16
}

////////////////////////////////////////////////////////////////////////////// CmdVoidU16 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidU16

func NewCmdVoidU16(
	pA uint16,
) *CmdVoidU16

func (*CmdVoidU16) API

func (c *CmdVoidU16) API() gfxapi.API

func (*CmdVoidU16) Class

func (*CmdVoidU16) Class() binary.Class

func (*CmdVoidU16) Flags

func (c *CmdVoidU16) Flags() atom.Flags

func (*CmdVoidU16) Mutate

func (ϟa *CmdVoidU16) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidU16) Replay

func (ϟa *CmdVoidU16) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidU16) String

func (c *CmdVoidU16) String() string

func (*CmdVoidU16) TypeID

func (c *CmdVoidU16) TypeID() atom.TypeID

type CmdVoidU32

type CmdVoidU32 struct {
	binary.Generate
	A uint32
}

////////////////////////////////////////////////////////////////////////////// CmdVoidU32 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidU32

func NewCmdVoidU32(
	pA uint32,
) *CmdVoidU32

func (*CmdVoidU32) API

func (c *CmdVoidU32) API() gfxapi.API

func (*CmdVoidU32) Class

func (*CmdVoidU32) Class() binary.Class

func (*CmdVoidU32) Flags

func (c *CmdVoidU32) Flags() atom.Flags

func (*CmdVoidU32) Mutate

func (ϟa *CmdVoidU32) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidU32) Replay

func (ϟa *CmdVoidU32) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidU32) String

func (c *CmdVoidU32) String() string

func (*CmdVoidU32) TypeID

func (c *CmdVoidU32) TypeID() atom.TypeID

type CmdVoidU64

type CmdVoidU64 struct {
	binary.Generate
	A uint64
}

////////////////////////////////////////////////////////////////////////////// CmdVoidU64 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidU64

func NewCmdVoidU64(
	pA uint64,
) *CmdVoidU64

func (*CmdVoidU64) API

func (c *CmdVoidU64) API() gfxapi.API

func (*CmdVoidU64) Class

func (*CmdVoidU64) Class() binary.Class

func (*CmdVoidU64) Flags

func (c *CmdVoidU64) Flags() atom.Flags

func (*CmdVoidU64) Mutate

func (ϟa *CmdVoidU64) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidU64) Replay

func (ϟa *CmdVoidU64) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidU64) String

func (c *CmdVoidU64) String() string

func (*CmdVoidU64) TypeID

func (c *CmdVoidU64) TypeID() atom.TypeID

type CmdVoidU8

type CmdVoidU8 struct {
	binary.Generate
	A uint8
}

////////////////////////////////////////////////////////////////////////////// CmdVoidU8 //////////////////////////////////////////////////////////////////////////////

func NewCmdVoidU8

func NewCmdVoidU8(
	pA uint8,
) *CmdVoidU8

func (*CmdVoidU8) API

func (c *CmdVoidU8) API() gfxapi.API

func (*CmdVoidU8) Class

func (*CmdVoidU8) Class() binary.Class

func (*CmdVoidU8) Flags

func (c *CmdVoidU8) Flags() atom.Flags

func (*CmdVoidU8) Mutate

func (ϟa *CmdVoidU8) Mutate(ϟs *gfxapi.State) error

func (*CmdVoidU8) Replay

func (ϟa *CmdVoidU8) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟb *builder.Builder, postback bool)

func (*CmdVoidU8) String

func (c *CmdVoidU8) String() string

func (*CmdVoidU8) TypeID

func (c *CmdVoidU8) TypeID() atom.TypeID

type F32Array

type F32Array []float32

func (F32Array) Len

func (s F32Array) Len() int

func (F32Array) Range

func (s F32Array) Range() []float32

type Globals

type Globals struct {
	binary.Generate
}

////////////////////////////////////////////////////////////////////////////// Globals //////////////////////////////////////////////////////////////////////////////

func (*Globals) Class

func (*Globals) Class() binary.Class

func (*Globals) Init

func (g *Globals) Init()

type RemappedArray

type RemappedArray []remapped

func (RemappedArray) Len

func (s RemappedArray) Len() int

func (RemappedArray) Range

func (s RemappedArray) Range() []remapped

type S8Array

type S8Array []int8

func (S8Array) Len

func (s S8Array) Len() int

func (S8Array) Range

func (s S8Array) Range() []int8

type State

type State struct {
	Globals
	ValidateOutput bool
}

type StringArray

type StringArray []string

func (StringArray) Len

func (s StringArray) Len() int

func (StringArray) Range

func (s StringArray) Range() []string