builder/builder_binary.go

////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////

package builder

import (
	"android.googlesource.com/platform/tools/gpu/atom"
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/any"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/image"
	"android.googlesource.com/platform/tools/gpu/service"
	"android.googlesource.com/platform/tools/gpu/service/path"
)

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*BuildReport)(nil).Class())
	Namespace.Add((*ConvertImage)(nil).Class())
	Namespace.Add((*Follow)(nil).Class())
	Namespace.Add((*Get)(nil).Class())
	Namespace.Add((*GetFramebufferColor)(nil).Class())
	Namespace.Add((*GetFramebufferDepth)(nil).Class())
	Namespace.Add((*GetHierarchy)(nil).Class())
	Namespace.Add((*GetState)(nil).Class())
	Namespace.Add((*GetTimingInfo)(nil).Class())
	Namespace.Add((*PrerenderFramebuffers)(nil).Class())
	Namespace.Add((*RenderFramebufferColor)(nil).Class())
	Namespace.Add((*RenderFramebufferDepth)(nil).Class())
	Namespace.Add((*Set)(nil).Class())
	Namespace.Add((*atomFramebufferDimensions)(nil).Class())
	Namespace.Add((*captureFramebufferDimensions)(nil).Class())
	Namespace.Add((*getCaptureFramebufferDimensions)(nil).Class())
}

var (
	binaryIDBuildReport                     = binary.ID{0x0d, 0xe5, 0xe5, 0x3d, 0xda, 0x87, 0xb3, 0x58, 0x27, 0x4f, 0x23, 0xcc, 0xfa, 0xa3, 0xd8, 0xd0, 0xda, 0x69, 0x46, 0x9c}
	binaryIDConvertImage                    = binary.ID{0x13, 0xc1, 0xbc, 0x41, 0x0c, 0xa1, 0x37, 0xf7, 0xf8, 0x64, 0x8c, 0xc5, 0xff, 0x10, 0xd3, 0x32, 0x49, 0xbb, 0xf9, 0x64}
	binaryIDFollow                          = binary.ID{0x48, 0x95, 0x04, 0x17, 0x0e, 0xe4, 0xc2, 0x25, 0x69, 0xe6, 0x51, 0xa5, 0x21, 0xf1, 0xa2, 0x7f, 0x5c, 0x9e, 0x32, 0xa7}
	binaryIDGet                             = binary.ID{0x82, 0xb2, 0x02, 0xb1, 0xbc, 0x47, 0xaa, 0x54, 0xed, 0xd7, 0xad, 0x46, 0x6e, 0x1d, 0xa3, 0x41, 0x16, 0x54, 0xd9, 0x15}
	binaryIDGetFramebufferColor             = binary.ID{0x1a, 0xcc, 0x5f, 0x4b, 0xe4, 0x22, 0xd7, 0x61, 0x00, 0xc8, 0xd8, 0x41, 0x30, 0xeb, 0xfe, 0x59, 0x7d, 0x4c, 0xbe, 0x9f}
	binaryIDGetFramebufferDepth             = binary.ID{0xa7, 0x03, 0x08, 0x3d, 0x42, 0xbc, 0x22, 0x83, 0x51, 0x9f, 0xc0, 0x5f, 0xa6, 0xa2, 0x1e, 0xa7, 0x5e, 0xd6, 0xc8, 0x03}
	binaryIDGetHierarchy                    = binary.ID{0xc8, 0x91, 0x63, 0x41, 0x37, 0x7e, 0x59, 0x37, 0xe2, 0x13, 0x28, 0xbc, 0xf0, 0xf1, 0x8c, 0x20, 0x26, 0x6d, 0xa7, 0x55}
	binaryIDGetState                        = binary.ID{0x40, 0xfb, 0x42, 0x18, 0xf5, 0x5c, 0xff, 0x11, 0x85, 0x82, 0xaf, 0xf4, 0x6d, 0xc5, 0xde, 0x19, 0x0b, 0x41, 0xba, 0x38}
	binaryIDGetTimingInfo                   = binary.ID{0x62, 0xaf, 0x98, 0x90, 0x77, 0x84, 0x30, 0xad, 0x1b, 0x37, 0x4d, 0x76, 0xdd, 0xc8, 0xd4, 0xda, 0x41, 0xe7, 0x99, 0xca}
	binaryIDPrerenderFramebuffers           = binary.ID{0xe5, 0x39, 0x5a, 0x38, 0x7e, 0xd7, 0xfd, 0x1d, 0xfd, 0xc8, 0x41, 0x0b, 0x7a, 0x55, 0x93, 0x3d, 0xdb, 0x51, 0x28, 0xce}
	binaryIDRenderFramebufferColor          = binary.ID{0xfe, 0xe2, 0x14, 0xdf, 0xc8, 0x0d, 0xed, 0x58, 0xe4, 0x56, 0xb8, 0xa9, 0x68, 0xd9, 0xc1, 0xa3, 0x50, 0xae, 0xa6, 0x78}
	binaryIDRenderFramebufferDepth          = binary.ID{0x92, 0xb5, 0x88, 0x2a, 0x1a, 0x6f, 0xa1, 0x3c, 0xff, 0x7a, 0x90, 0xb3, 0x21, 0xa9, 0xe0, 0x67, 0xf4, 0x2c, 0x9e, 0x82}
	binaryIDSet                             = binary.ID{0x3e, 0x3e, 0xf7, 0x61, 0xd5, 0x5c, 0x3a, 0x76, 0xc6, 0x39, 0x17, 0x5e, 0x37, 0x26, 0x78, 0xaf, 0xdf, 0x83, 0x9f, 0x4e}
	binaryIDatomFramebufferDimensions       = binary.ID{0xb6, 0xbb, 0x6b, 0x01, 0xb6, 0x82, 0xdb, 0x1f, 0xca, 0x6c, 0x74, 0x22, 0xc4, 0x74, 0xca, 0x61, 0xdd, 0x28, 0xe6, 0xf3}
	binaryIDcaptureFramebufferDimensions    = binary.ID{0xb6, 0xbf, 0x92, 0x09, 0xa7, 0xde, 0x07, 0xf3, 0x0d, 0x9b, 0x37, 0xf8, 0x67, 0x83, 0x83, 0xbb, 0xb4, 0x8b, 0x53, 0xf5}
	binaryIDgetCaptureFramebufferDimensions = binary.ID{0x27, 0x96, 0x78, 0xb6, 0x8e, 0x91, 0x8f, 0x13, 0x09, 0x07, 0xb7, 0x09, 0x0d, 0x2b, 0xc2, 0xf7, 0xc9, 0xa5, 0x7d, 0x08}
)

type binaryClassBuildReport struct{}

func (*BuildReport) Class() binary.Class {
	return (*binaryClassBuildReport)(nil)
}
func doEncodeBuildReport(e binary.Encoder, o *BuildReport) error {
	if o.Capture != nil {
		if err := e.Object(o.Capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeBuildReport(d binary.Decoder, o *BuildReport) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	return nil
}
func doSkipBuildReport(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBuildReport) ID() binary.ID      { return binaryIDBuildReport }
func (*binaryClassBuildReport) New() binary.Object { return &BuildReport{} }
func (*binaryClassBuildReport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBuildReport(e, obj.(*BuildReport))
}
func (*binaryClassBuildReport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BuildReport{}
	return obj, doDecodeBuildReport(d, obj)
}
func (*binaryClassBuildReport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBuildReport(d, obj.(*BuildReport))
}
func (*binaryClassBuildReport) Skip(d binary.Decoder) error { return doSkipBuildReport(d) }
func (*binaryClassBuildReport) Schema() *schema.Class       { return schemaBuildReport }

var schemaBuildReport = &schema.Class{
	TypeID:  binaryIDBuildReport,
	Package: "builder",
	Name:    "BuildReport",
	Fields: []schema.Field{
		{Declared: "Capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
	},
}

type binaryClassConvertImage struct{}

func (*ConvertImage) Class() binary.Class {
	return (*binaryClassConvertImage)(nil)
}
func doEncodeConvertImage(e binary.Encoder, o *ConvertImage) error {
	if err := e.ID(o.Data); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if o.FormatFrom != nil {
		if err := e.Object(o.FormatFrom); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.FormatTo != nil {
		if err := e.Object(o.FormatTo); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeConvertImage(d binary.Decoder, o *ConvertImage) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.Data = binary.ID(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = int(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = int(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.FormatFrom = obj.(image.Format)
	} else {
		o.FormatFrom = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.FormatTo = obj.(image.Format)
	} else {
		o.FormatTo = nil
	}
	return nil
}
func doSkipConvertImage(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassConvertImage) ID() binary.ID      { return binaryIDConvertImage }
func (*binaryClassConvertImage) New() binary.Object { return &ConvertImage{} }
func (*binaryClassConvertImage) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeConvertImage(e, obj.(*ConvertImage))
}
func (*binaryClassConvertImage) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ConvertImage{}
	return obj, doDecodeConvertImage(d, obj)
}
func (*binaryClassConvertImage) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeConvertImage(d, obj.(*ConvertImage))
}
func (*binaryClassConvertImage) Skip(d binary.Decoder) error { return doSkipConvertImage(d) }
func (*binaryClassConvertImage) Schema() *schema.Class       { return schemaConvertImage }

var schemaConvertImage = &schema.Class{
	TypeID:  binaryIDConvertImage,
	Package: "builder",
	Name:    "ConvertImage",
	Fields: []schema.Field{
		{Declared: "Data", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
		{Declared: "Width", Type: &schema.Primitive{Name: "int", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "int", Method: schema.Int32}},
		{Declared: "FormatFrom", Type: &schema.Interface{Name: "image.Format"}},
		{Declared: "FormatTo", Type: &schema.Interface{Name: "image.Format"}},
	},
}

type binaryClassFollow struct{}

func (*Follow) Class() binary.Class {
	return (*binaryClassFollow)(nil)
}
func doEncodeFollow(e binary.Encoder, o *Follow) error {
	if o.Path != nil {
		if err := e.Object(o.Path); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeFollow(d binary.Decoder, o *Follow) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Path = obj.(path.Path)
	} else {
		o.Path = nil
	}
	return nil
}
func doSkipFollow(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFollow) ID() binary.ID      { return binaryIDFollow }
func (*binaryClassFollow) New() binary.Object { return &Follow{} }
func (*binaryClassFollow) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFollow(e, obj.(*Follow))
}
func (*binaryClassFollow) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Follow{}
	return obj, doDecodeFollow(d, obj)
}
func (*binaryClassFollow) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFollow(d, obj.(*Follow))
}
func (*binaryClassFollow) Skip(d binary.Decoder) error { return doSkipFollow(d) }
func (*binaryClassFollow) Schema() *schema.Class       { return schemaFollow }

var schemaFollow = &schema.Class{
	TypeID:  binaryIDFollow,
	Package: "builder",
	Name:    "Follow",
	Fields: []schema.Field{
		{Declared: "Path", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClassGet struct{}

func (*Get) Class() binary.Class {
	return (*binaryClassGet)(nil)
}
func doEncodeGet(e binary.Encoder, o *Get) error {
	if o.Path != nil {
		if err := e.Object(o.Path); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeGet(d binary.Decoder, o *Get) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Path = obj.(path.Path)
	} else {
		o.Path = nil
	}
	return nil
}
func doSkipGet(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGet) ID() binary.ID      { return binaryIDGet }
func (*binaryClassGet) New() binary.Object { return &Get{} }
func (*binaryClassGet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGet(e, obj.(*Get))
}
func (*binaryClassGet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Get{}
	return obj, doDecodeGet(d, obj)
}
func (*binaryClassGet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGet(d, obj.(*Get))
}
func (*binaryClassGet) Skip(d binary.Decoder) error { return doSkipGet(d) }
func (*binaryClassGet) Schema() *schema.Class       { return schemaGet }

var schemaGet = &schema.Class{
	TypeID:  binaryIDGet,
	Package: "builder",
	Name:    "Get",
	Fields: []schema.Field{
		{Declared: "Path", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClassGetFramebufferColor struct{}

func (*GetFramebufferColor) Class() binary.Class {
	return (*binaryClassGetFramebufferColor)(nil)
}
func doEncodeGetFramebufferColor(e binary.Encoder, o *GetFramebufferColor) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.After != nil {
		if err := e.Object(o.After); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Value(&o.Settings); err != nil {
		return err
	}
	return nil
}
func doDecodeGetFramebufferColor(d binary.Decoder, o *GetFramebufferColor) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	if err := d.Value(&o.Settings); err != nil {
		return err
	}
	return nil
}
func doSkipGetFramebufferColor(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if err := d.SkipValue((*service.RenderSettings)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetFramebufferColor) ID() binary.ID      { return binaryIDGetFramebufferColor }
func (*binaryClassGetFramebufferColor) New() binary.Object { return &GetFramebufferColor{} }
func (*binaryClassGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetFramebufferColor(e, obj.(*GetFramebufferColor))
}
func (*binaryClassGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetFramebufferColor{}
	return obj, doDecodeGetFramebufferColor(d, obj)
}
func (*binaryClassGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetFramebufferColor(d, obj.(*GetFramebufferColor))
}
func (*binaryClassGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipGetFramebufferColor(d)
}
func (*binaryClassGetFramebufferColor) Schema() *schema.Class { return schemaGetFramebufferColor }

var schemaGetFramebufferColor = &schema.Class{
	TypeID:  binaryIDGetFramebufferColor,
	Package: "builder",
	Name:    "GetFramebufferColor",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "After", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
		{Declared: "Settings", Type: &schema.Struct{Name: "service.RenderSettings", ID: (*service.RenderSettings)(nil).Class().ID()}},
	},
}

type binaryClassGetFramebufferDepth struct{}

func (*GetFramebufferDepth) Class() binary.Class {
	return (*binaryClassGetFramebufferDepth)(nil)
}
func doEncodeGetFramebufferDepth(e binary.Encoder, o *GetFramebufferDepth) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.After != nil {
		if err := e.Object(o.After); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeGetFramebufferDepth(d binary.Decoder, o *GetFramebufferDepth) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	return nil
}
func doSkipGetFramebufferDepth(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetFramebufferDepth) ID() binary.ID      { return binaryIDGetFramebufferDepth }
func (*binaryClassGetFramebufferDepth) New() binary.Object { return &GetFramebufferDepth{} }
func (*binaryClassGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetFramebufferDepth(e, obj.(*GetFramebufferDepth))
}
func (*binaryClassGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetFramebufferDepth{}
	return obj, doDecodeGetFramebufferDepth(d, obj)
}
func (*binaryClassGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetFramebufferDepth(d, obj.(*GetFramebufferDepth))
}
func (*binaryClassGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipGetFramebufferDepth(d)
}
func (*binaryClassGetFramebufferDepth) Schema() *schema.Class { return schemaGetFramebufferDepth }

var schemaGetFramebufferDepth = &schema.Class{
	TypeID:  binaryIDGetFramebufferDepth,
	Package: "builder",
	Name:    "GetFramebufferDepth",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "After", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
	},
}

type binaryClassGetHierarchy struct{}

func (*GetHierarchy) Class() binary.Class {
	return (*binaryClassGetHierarchy)(nil)
}
func doEncodeGetHierarchy(e binary.Encoder, o *GetHierarchy) error {
	if o.Capture != nil {
		if err := e.Object(o.Capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeGetHierarchy(d binary.Decoder, o *GetHierarchy) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	return nil
}
func doSkipGetHierarchy(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetHierarchy) ID() binary.ID      { return binaryIDGetHierarchy }
func (*binaryClassGetHierarchy) New() binary.Object { return &GetHierarchy{} }
func (*binaryClassGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetHierarchy(e, obj.(*GetHierarchy))
}
func (*binaryClassGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetHierarchy{}
	return obj, doDecodeGetHierarchy(d, obj)
}
func (*binaryClassGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetHierarchy(d, obj.(*GetHierarchy))
}
func (*binaryClassGetHierarchy) Skip(d binary.Decoder) error { return doSkipGetHierarchy(d) }
func (*binaryClassGetHierarchy) Schema() *schema.Class       { return schemaGetHierarchy }

var schemaGetHierarchy = &schema.Class{
	TypeID:  binaryIDGetHierarchy,
	Package: "builder",
	Name:    "GetHierarchy",
	Fields: []schema.Field{
		{Declared: "Capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
	},
}

type binaryClassGetState struct{}

func (*GetState) Class() binary.Class {
	return (*binaryClassGetState)(nil)
}
func doEncodeGetState(e binary.Encoder, o *GetState) error {
	if o.After != nil {
		if err := e.Object(o.After); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeGetState(d binary.Decoder, o *GetState) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	return nil
}
func doSkipGetState(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetState) ID() binary.ID      { return binaryIDGetState }
func (*binaryClassGetState) New() binary.Object { return &GetState{} }
func (*binaryClassGetState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetState(e, obj.(*GetState))
}
func (*binaryClassGetState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetState{}
	return obj, doDecodeGetState(d, obj)
}
func (*binaryClassGetState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetState(d, obj.(*GetState))
}
func (*binaryClassGetState) Skip(d binary.Decoder) error { return doSkipGetState(d) }
func (*binaryClassGetState) Schema() *schema.Class       { return schemaGetState }

var schemaGetState = &schema.Class{
	TypeID:  binaryIDGetState,
	Package: "builder",
	Name:    "GetState",
	Fields: []schema.Field{
		{Declared: "After", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
	},
}

type binaryClassGetTimingInfo struct{}

func (*GetTimingInfo) Class() binary.Class {
	return (*binaryClassGetTimingInfo)(nil)
}
func doEncodeGetTimingInfo(e binary.Encoder, o *GetTimingInfo) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.Capture != nil {
		if err := e.Object(o.Capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Flags)); err != nil {
		return err
	}
	return nil
}
func doDecodeGetTimingInfo(d binary.Decoder, o *GetTimingInfo) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Flags = service.TimingFlags(obj)
	}
	return nil
}
func doSkipGetTimingInfo(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetTimingInfo) ID() binary.ID      { return binaryIDGetTimingInfo }
func (*binaryClassGetTimingInfo) New() binary.Object { return &GetTimingInfo{} }
func (*binaryClassGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetTimingInfo(e, obj.(*GetTimingInfo))
}
func (*binaryClassGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetTimingInfo{}
	return obj, doDecodeGetTimingInfo(d, obj)
}
func (*binaryClassGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetTimingInfo(d, obj.(*GetTimingInfo))
}
func (*binaryClassGetTimingInfo) Skip(d binary.Decoder) error { return doSkipGetTimingInfo(d) }
func (*binaryClassGetTimingInfo) Schema() *schema.Class       { return schemaGetTimingInfo }

var schemaGetTimingInfo = &schema.Class{
	TypeID:  binaryIDGetTimingInfo,
	Package: "builder",
	Name:    "GetTimingInfo",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "Capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
		{Declared: "Flags", Type: &schema.Primitive{Name: "service.TimingFlags", Method: schema.Int32}},
	},
}

type binaryClassPrerenderFramebuffers struct{}

func (*PrerenderFramebuffers) Class() binary.Class {
	return (*binaryClassPrerenderFramebuffers)(nil)
}
func doEncodePrerenderFramebuffers(e binary.Encoder, o *PrerenderFramebuffers) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.Capture != nil {
		if err := e.Object(o.Capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.ID(binary.ID(o.API)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.AtomIDs))); err != nil {
		return err
	}
	for i := range o.AtomIDs {
		if err := e.Uint64(o.AtomIDs[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	return nil
}
func doDecodePrerenderFramebuffers(d binary.Decoder, o *PrerenderFramebuffers) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.API = service.ApiID(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.AtomIDs = make([]uint64, count)
		for i := range o.AtomIDs {
			if obj, err := d.Uint64(); err != nil {
				return err
			} else {
				o.AtomIDs[i] = uint64(obj)
			}
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	return nil
}
func doSkipPrerenderFramebuffers(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if err := d.SkipID(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint64(); err != nil {
				return err
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassPrerenderFramebuffers) ID() binary.ID      { return binaryIDPrerenderFramebuffers }
func (*binaryClassPrerenderFramebuffers) New() binary.Object { return &PrerenderFramebuffers{} }
func (*binaryClassPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodePrerenderFramebuffers(e, obj.(*PrerenderFramebuffers))
}
func (*binaryClassPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &PrerenderFramebuffers{}
	return obj, doDecodePrerenderFramebuffers(d, obj)
}
func (*binaryClassPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodePrerenderFramebuffers(d, obj.(*PrerenderFramebuffers))
}
func (*binaryClassPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipPrerenderFramebuffers(d)
}
func (*binaryClassPrerenderFramebuffers) Schema() *schema.Class { return schemaPrerenderFramebuffers }

var schemaPrerenderFramebuffers = &schema.Class{
	TypeID:  binaryIDPrerenderFramebuffers,
	Package: "builder",
	Name:    "PrerenderFramebuffers",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "Capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
		{Declared: "API", Type: &schema.Primitive{Name: "service.ApiID", Method: schema.ID}},
		{Declared: "AtomIDs", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}},
		{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassRenderFramebufferColor struct{}

func (*RenderFramebufferColor) Class() binary.Class {
	return (*binaryClassRenderFramebufferColor)(nil)
}
func doEncodeRenderFramebufferColor(e binary.Encoder, o *RenderFramebufferColor) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.After != nil {
		if err := e.Object(o.After); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	if err := e.Int32(int32(o.WireframeMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderFramebufferColor(d binary.Decoder, o *RenderFramebufferColor) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.WireframeMode = service.WireframeMode(obj)
	}
	return nil
}
func doSkipRenderFramebufferColor(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderFramebufferColor) ID() binary.ID      { return binaryIDRenderFramebufferColor }
func (*binaryClassRenderFramebufferColor) New() binary.Object { return &RenderFramebufferColor{} }
func (*binaryClassRenderFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderFramebufferColor(e, obj.(*RenderFramebufferColor))
}
func (*binaryClassRenderFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderFramebufferColor{}
	return obj, doDecodeRenderFramebufferColor(d, obj)
}
func (*binaryClassRenderFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderFramebufferColor(d, obj.(*RenderFramebufferColor))
}
func (*binaryClassRenderFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipRenderFramebufferColor(d)
}
func (*binaryClassRenderFramebufferColor) Schema() *schema.Class { return schemaRenderFramebufferColor }

var schemaRenderFramebufferColor = &schema.Class{
	TypeID:  binaryIDRenderFramebufferColor,
	Package: "builder",
	Name:    "RenderFramebufferColor",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "After", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
		{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "WireframeMode", Type: &schema.Primitive{Name: "service.WireframeMode", Method: schema.Int32}},
	},
}

type binaryClassRenderFramebufferDepth struct{}

func (*RenderFramebufferDepth) Class() binary.Class {
	return (*binaryClassRenderFramebufferDepth)(nil)
}
func doEncodeRenderFramebufferDepth(e binary.Encoder, o *RenderFramebufferDepth) error {
	if o.Device != nil {
		if err := e.Object(o.Device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.After != nil {
		if err := e.Object(o.After); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Uint32(o.FramebufferWidth); err != nil {
		return err
	}
	if err := e.Uint32(o.FramebufferHeight); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderFramebufferDepth(d binary.Decoder, o *RenderFramebufferDepth) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferWidth = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferHeight = uint32(obj)
	}
	return nil
}
func doSkipRenderFramebufferDepth(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderFramebufferDepth) ID() binary.ID      { return binaryIDRenderFramebufferDepth }
func (*binaryClassRenderFramebufferDepth) New() binary.Object { return &RenderFramebufferDepth{} }
func (*binaryClassRenderFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderFramebufferDepth(e, obj.(*RenderFramebufferDepth))
}
func (*binaryClassRenderFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderFramebufferDepth{}
	return obj, doDecodeRenderFramebufferDepth(d, obj)
}
func (*binaryClassRenderFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderFramebufferDepth(d, obj.(*RenderFramebufferDepth))
}
func (*binaryClassRenderFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipRenderFramebufferDepth(d)
}
func (*binaryClassRenderFramebufferDepth) Schema() *schema.Class { return schemaRenderFramebufferDepth }

var schemaRenderFramebufferDepth = &schema.Class{
	TypeID:  binaryIDRenderFramebufferDepth,
	Package: "builder",
	Name:    "RenderFramebufferDepth",
	Fields: []schema.Field{
		{Declared: "Device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "After", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
		{Declared: "FramebufferWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "FramebufferHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassSet struct{}

func (*Set) Class() binary.Class {
	return (*binaryClassSet)(nil)
}
func doEncodeSet(e binary.Encoder, o *Set) error {
	if o.Path != nil {
		if err := e.Object(o.Path); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.Value != nil {
		var boxed binary.Object
		boxed, err := any.Box(o.Value)
		if err != nil {
			return err
		}
		if err := e.Variant(boxed); err != nil {
			return err
		}
	} else if err := e.Variant(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeSet(d binary.Decoder, o *Set) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Path = obj.(path.Path)
	} else {
		o.Path = nil
	}
	if boxed, err := d.Variant(); err != nil {
		return err
	} else if boxed != nil {
		if o.Value, err = any.Unbox(boxed); err != nil {
			return err
		}
	} else {
		o.Value = nil
	}
	return nil
}
func doSkipSet(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipVariant(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSet) ID() binary.ID      { return binaryIDSet }
func (*binaryClassSet) New() binary.Object { return &Set{} }
func (*binaryClassSet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSet(e, obj.(*Set))
}
func (*binaryClassSet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Set{}
	return obj, doDecodeSet(d, obj)
}
func (*binaryClassSet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSet(d, obj.(*Set))
}
func (*binaryClassSet) Skip(d binary.Decoder) error { return doSkipSet(d) }
func (*binaryClassSet) Schema() *schema.Class       { return schemaSet }

var schemaSet = &schema.Class{
	TypeID:  binaryIDSet,
	Package: "builder",
	Name:    "Set",
	Fields: []schema.Field{
		{Declared: "Path", Type: &schema.Interface{Name: "path.Path"}},
		{Declared: "Value", Type: &any.Any{}},
	},
}

type binaryClassatomFramebufferDimensions struct{}

func (*atomFramebufferDimensions) Class() binary.Class {
	return (*binaryClassatomFramebufferDimensions)(nil)
}
func doEncodeatomFramebufferDimensions(e binary.Encoder, o *atomFramebufferDimensions) error {
	if err := e.Uint64(uint64(o.From)); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	return nil
}
func doDecodeatomFramebufferDimensions(d binary.Decoder, o *atomFramebufferDimensions) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.From = atom.ID(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	return nil
}
func doSkipatomFramebufferDimensions(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassatomFramebufferDimensions) ID() binary.ID      { return binaryIDatomFramebufferDimensions }
func (*binaryClassatomFramebufferDimensions) New() binary.Object { return &atomFramebufferDimensions{} }
func (*binaryClassatomFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeatomFramebufferDimensions(e, obj.(*atomFramebufferDimensions))
}
func (*binaryClassatomFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &atomFramebufferDimensions{}
	return obj, doDecodeatomFramebufferDimensions(d, obj)
}
func (*binaryClassatomFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeatomFramebufferDimensions(d, obj.(*atomFramebufferDimensions))
}
func (*binaryClassatomFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipatomFramebufferDimensions(d)
}
func (*binaryClassatomFramebufferDimensions) Schema() *schema.Class {
	return schemaatomFramebufferDimensions
}

var schemaatomFramebufferDimensions = &schema.Class{
	TypeID:  binaryIDatomFramebufferDimensions,
	Package: "builder",
	Name:    "atomFramebufferDimensions",
	Fields: []schema.Field{
		{Declared: "From", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClasscaptureFramebufferDimensions struct{}

func (*captureFramebufferDimensions) Class() binary.Class {
	return (*binaryClasscaptureFramebufferDimensions)(nil)
}
func doEncodecaptureFramebufferDimensions(e binary.Encoder, o *captureFramebufferDimensions) error {
	if err := e.Uint32(uint32(len(o.Dimensions))); err != nil {
		return err
	}
	for i := range o.Dimensions {
		if err := e.Value(&o.Dimensions[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodecaptureFramebufferDimensions(d binary.Decoder, o *captureFramebufferDimensions) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Dimensions = make([]atomFramebufferDimensions, count)
		for i := range o.Dimensions {
			if err := d.Value(&o.Dimensions[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipcaptureFramebufferDimensions(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*atomFramebufferDimensions)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasscaptureFramebufferDimensions) ID() binary.ID {
	return binaryIDcaptureFramebufferDimensions
}
func (*binaryClasscaptureFramebufferDimensions) New() binary.Object {
	return &captureFramebufferDimensions{}
}
func (*binaryClasscaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecaptureFramebufferDimensions(e, obj.(*captureFramebufferDimensions))
}
func (*binaryClasscaptureFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &captureFramebufferDimensions{}
	return obj, doDecodecaptureFramebufferDimensions(d, obj)
}
func (*binaryClasscaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecaptureFramebufferDimensions(d, obj.(*captureFramebufferDimensions))
}
func (*binaryClasscaptureFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipcaptureFramebufferDimensions(d)
}
func (*binaryClasscaptureFramebufferDimensions) Schema() *schema.Class {
	return schemacaptureFramebufferDimensions
}

var schemacaptureFramebufferDimensions = &schema.Class{
	TypeID:  binaryIDcaptureFramebufferDimensions,
	Package: "builder",
	Name:    "captureFramebufferDimensions",
	Fields: []schema.Field{
		{Declared: "Dimensions", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "atomFramebufferDimensions", ID: (*atomFramebufferDimensions)(nil).Class().ID()}}},
	},
}

type binaryClassgetCaptureFramebufferDimensions struct{}

func (*getCaptureFramebufferDimensions) Class() binary.Class {
	return (*binaryClassgetCaptureFramebufferDimensions)(nil)
}
func doEncodegetCaptureFramebufferDimensions(e binary.Encoder, o *getCaptureFramebufferDimensions) error {
	if o.Capture != nil {
		if err := e.Object(o.Capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodegetCaptureFramebufferDimensions(d binary.Decoder, o *getCaptureFramebufferDimensions) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	return nil
}
func doSkipgetCaptureFramebufferDimensions(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassgetCaptureFramebufferDimensions) ID() binary.ID {
	return binaryIDgetCaptureFramebufferDimensions
}
func (*binaryClassgetCaptureFramebufferDimensions) New() binary.Object {
	return &getCaptureFramebufferDimensions{}
}
func (*binaryClassgetCaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodegetCaptureFramebufferDimensions(e, obj.(*getCaptureFramebufferDimensions))
}
func (*binaryClassgetCaptureFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &getCaptureFramebufferDimensions{}
	return obj, doDecodegetCaptureFramebufferDimensions(d, obj)
}
func (*binaryClassgetCaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodegetCaptureFramebufferDimensions(d, obj.(*getCaptureFramebufferDimensions))
}
func (*binaryClassgetCaptureFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipgetCaptureFramebufferDimensions(d)
}
func (*binaryClassgetCaptureFramebufferDimensions) Schema() *schema.Class {
	return schemagetCaptureFramebufferDimensions
}

var schemagetCaptureFramebufferDimensions = &schema.Class{
	TypeID:  binaryIDgetCaptureFramebufferDimensions,
	Package: "builder",
	Name:    "getCaptureFramebufferDimensions",
	Fields: []schema.Field{
		{Declared: "Capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
	},
}