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/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/service"
	"android.googlesource.com/platform/tools/gpu/service/path"
)

// Make sure schema init() runs first
import _ "android.googlesource.com/platform/tools/gpu/binary/schema"

const (
	ixǁBuildReport = iota
	ixǁFollow
	ixǁGet
	ixǁGetFramebufferColor
	ixǁGetFramebufferDepth
	ixǁGetHierarchy
	ixǁGetResourceData
	ixǁGetResources
	ixǁGetState
	ixǁGetTimingInfo
	ixǁIndexLimits
	ixǁRenderFramebufferColor
	ixǁRenderFramebufferDepth
	ixǁSet
	ixǁatomFramebufferDimensions
	ixǁcalcIndexLimits
	ixǁcaptureFramebufferDimensions
	ixǁgetCaptureFramebufferDimensions
)

var entities [18]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*BuildReport)(nil))
	Namespace.AddClassOf((*Follow)(nil))
	Namespace.AddClassOf((*Get)(nil))
	Namespace.AddClassOf((*GetFramebufferColor)(nil))
	Namespace.AddClassOf((*GetFramebufferDepth)(nil))
	Namespace.AddClassOf((*GetHierarchy)(nil))
	Namespace.AddClassOf((*GetResourceData)(nil))
	Namespace.AddClassOf((*GetResources)(nil))
	Namespace.AddClassOf((*GetState)(nil))
	Namespace.AddClassOf((*GetTimingInfo)(nil))
	Namespace.AddClassOf((*IndexLimits)(nil))
	Namespace.AddClassOf((*RenderFramebufferColor)(nil))
	Namespace.AddClassOf((*RenderFramebufferDepth)(nil))
	Namespace.AddClassOf((*Set)(nil))
	Namespace.AddClassOf((*atomFramebufferDimensions)(nil))
	Namespace.AddClassOf((*calcIndexLimits)(nil))
	Namespace.AddClassOf((*captureFramebufferDimensions)(nil))
	Namespace.AddClassOf((*getCaptureFramebufferDimensions)(nil))
}

type binaryClassBuildReport struct{}

func (*BuildReport) Class() binary.Class {
	return (*binaryClassBuildReport)(nil)
}
func doEncodeBuildReport(e binary.Encoder, o *BuildReport) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
}
func doDecodeBuildReport(d binary.Decoder, o *BuildReport) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
}
func (*binaryClassBuildReport) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBuildReport(e, obj.(*BuildReport))
}
func (*binaryClassBuildReport) New() binary.Object {
	return &BuildReport{}
}
func (*binaryClassBuildReport) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBuildReport(d, obj.(*BuildReport))
}
func (c *binaryClassBuildReport) Schema() *binary.Entity {
	return &entities[ixǁBuildReport]
}

type binaryClassFollow struct{}

func (*Follow) Class() binary.Class {
	return (*binaryClassFollow)(nil)
}
func doEncodeFollow(e binary.Encoder, o *Follow) {
	e.Object(o.Path)
}
func doDecodeFollow(d binary.Decoder, o *Follow) {
	o.Path = path.PathCast(d.Object())
}
func (*binaryClassFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFollow(e, obj.(*Follow))
}
func (*binaryClassFollow) New() binary.Object {
	return &Follow{}
}
func (*binaryClassFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFollow(d, obj.(*Follow))
}
func (c *binaryClassFollow) Schema() *binary.Entity {
	return &entities[ixǁFollow]
}

type binaryClassGet struct{}

func (*Get) Class() binary.Class {
	return (*binaryClassGet)(nil)
}
func doEncodeGet(e binary.Encoder, o *Get) {
	e.Object(o.Path)
}
func doDecodeGet(d binary.Decoder, o *Get) {
	o.Path = path.PathCast(d.Object())
}
func (*binaryClassGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGet(e, obj.(*Get))
}
func (*binaryClassGet) New() binary.Object {
	return &Get{}
}
func (*binaryClassGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGet(d, obj.(*Get))
}
func (c *binaryClassGet) Schema() *binary.Entity {
	return &entities[ixǁGet]
}

type binaryClassGetFramebufferColor struct{}

func (*GetFramebufferColor) Class() binary.Class {
	return (*binaryClassGetFramebufferColor)(nil)
}
func doEncodeGetFramebufferColor(e binary.Encoder, o *GetFramebufferColor) {
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
	e.Simple(&o.Settings)
}
func doDecodeGetFramebufferColor(d binary.Decoder, o *GetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj := d.Object(); obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	d.Simple(&o.Settings)
}
func (*binaryClassGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetFramebufferColor(e, obj.(*GetFramebufferColor))
}
func (*binaryClassGetFramebufferColor) New() binary.Object {
	return &GetFramebufferColor{}
}
func (*binaryClassGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetFramebufferColor(d, obj.(*GetFramebufferColor))
}
func (c *binaryClassGetFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁGetFramebufferColor]
}

type binaryClassGetFramebufferDepth struct{}

func (*GetFramebufferDepth) Class() binary.Class {
	return (*binaryClassGetFramebufferDepth)(nil)
}
func doEncodeGetFramebufferDepth(e binary.Encoder, o *GetFramebufferDepth) {
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
}
func doDecodeGetFramebufferDepth(d binary.Decoder, o *GetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj := d.Object(); obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
}
func (*binaryClassGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetFramebufferDepth(e, obj.(*GetFramebufferDepth))
}
func (*binaryClassGetFramebufferDepth) New() binary.Object {
	return &GetFramebufferDepth{}
}
func (*binaryClassGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetFramebufferDepth(d, obj.(*GetFramebufferDepth))
}
func (c *binaryClassGetFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁGetFramebufferDepth]
}

type binaryClassGetHierarchy struct{}

func (*GetHierarchy) Class() binary.Class {
	return (*binaryClassGetHierarchy)(nil)
}
func doEncodeGetHierarchy(e binary.Encoder, o *GetHierarchy) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeGetHierarchy(d binary.Decoder, o *GetHierarchy) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassGetHierarchy) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetHierarchy(e, obj.(*GetHierarchy))
}
func (*binaryClassGetHierarchy) New() binary.Object {
	return &GetHierarchy{}
}
func (*binaryClassGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetHierarchy(d, obj.(*GetHierarchy))
}
func (c *binaryClassGetHierarchy) Schema() *binary.Entity {
	return &entities[ixǁGetHierarchy]
}

type binaryClassGetResourceData struct{}

func (*GetResourceData) Class() binary.Class {
	return (*binaryClassGetResourceData)(nil)
}
func doEncodeGetResourceData(e binary.Encoder, o *GetResourceData) {
	if o.Path != nil {
		e.Object(o.Path)
	} else {
		e.Object(nil)
	}
}
func doDecodeGetResourceData(d binary.Decoder, o *GetResourceData) {
	if obj := d.Object(); obj != nil {
		o.Path = obj.(*path.Resource)
	} else {
		o.Path = nil
	}
}
func (*binaryClassGetResourceData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetResourceData(e, obj.(*GetResourceData))
}
func (*binaryClassGetResourceData) New() binary.Object {
	return &GetResourceData{}
}
func (*binaryClassGetResourceData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetResourceData(d, obj.(*GetResourceData))
}
func (c *binaryClassGetResourceData) Schema() *binary.Entity {
	return &entities[ixǁGetResourceData]
}

type binaryClassGetResources struct{}

func (*GetResources) Class() binary.Class {
	return (*binaryClassGetResources)(nil)
}
func doEncodeGetResources(e binary.Encoder, o *GetResources) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeGetResources(d binary.Decoder, o *GetResources) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassGetResources) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetResources(e, obj.(*GetResources))
}
func (*binaryClassGetResources) New() binary.Object {
	return &GetResources{}
}
func (*binaryClassGetResources) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetResources(d, obj.(*GetResources))
}
func (c *binaryClassGetResources) Schema() *binary.Entity {
	return &entities[ixǁGetResources]
}

type binaryClassGetState struct{}

func (*GetState) Class() binary.Class {
	return (*binaryClassGetState)(nil)
}
func doEncodeGetState(e binary.Encoder, o *GetState) {
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
}
func doDecodeGetState(d binary.Decoder, o *GetState) {
	if obj := d.Object(); obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
}
func (*binaryClassGetState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetState(e, obj.(*GetState))
}
func (*binaryClassGetState) New() binary.Object {
	return &GetState{}
}
func (*binaryClassGetState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetState(d, obj.(*GetState))
}
func (c *binaryClassGetState) Schema() *binary.Entity {
	return &entities[ixǁGetState]
}

type binaryClassGetTimingInfo struct{}

func (*GetTimingInfo) Class() binary.Class {
	return (*binaryClassGetTimingInfo)(nil)
}
func doEncodeGetTimingInfo(e binary.Encoder, o *GetTimingInfo) {
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
	e.Int32(int32(o.Flags))
}
func doDecodeGetTimingInfo(d binary.Decoder, o *GetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
	o.Flags = service.TimingFlags(d.Int32())
}
func (*binaryClassGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGetTimingInfo(e, obj.(*GetTimingInfo))
}
func (*binaryClassGetTimingInfo) New() binary.Object {
	return &GetTimingInfo{}
}
func (*binaryClassGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGetTimingInfo(d, obj.(*GetTimingInfo))
}
func (c *binaryClassGetTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁGetTimingInfo]
}

type binaryClassIndexLimits struct{}

func (*IndexLimits) Class() binary.Class {
	return (*binaryClassIndexLimits)(nil)
}
func doEncodeIndexLimits(e binary.Writer, o *IndexLimits) {
	e.Uint32(o.Min)
	e.Uint32(o.Max)
}
func doDecodeIndexLimits(d binary.Reader, o *IndexLimits) {
	o.Min = uint32(d.Uint32())
	o.Max = uint32(d.Uint32())
}
func (*binaryClassIndexLimits) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeIndexLimits(e, obj.(*IndexLimits))
}
func (*binaryClassIndexLimits) New() binary.Object {
	return &IndexLimits{}
}
func (*binaryClassIndexLimits) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeIndexLimits(d, obj.(*IndexLimits))
}
func (o *IndexLimits) WriteSimple(w binary.Writer) {
	doEncodeIndexLimits(w, o)
}
func (o *IndexLimits) ReadSimple(r binary.Reader) {
	doDecodeIndexLimits(r, o)
}
func (c *binaryClassIndexLimits) Schema() *binary.Entity {
	return &entities[ixǁIndexLimits]
}

type binaryClassRenderFramebufferColor struct{}

func (*RenderFramebufferColor) Class() binary.Class {
	return (*binaryClassRenderFramebufferColor)(nil)
}
func doEncodeRenderFramebufferColor(e binary.Encoder, o *RenderFramebufferColor) {
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
	e.Uint32(o.Width)
	e.Uint32(o.Height)
	e.Int32(int32(o.WireframeMode))
}
func doDecodeRenderFramebufferColor(d binary.Decoder, o *RenderFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj := d.Object(); obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	o.WireframeMode = service.WireframeMode(d.Int32())
}
func (*binaryClassRenderFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderFramebufferColor(e, obj.(*RenderFramebufferColor))
}
func (*binaryClassRenderFramebufferColor) New() binary.Object {
	return &RenderFramebufferColor{}
}
func (*binaryClassRenderFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderFramebufferColor(d, obj.(*RenderFramebufferColor))
}
func (c *binaryClassRenderFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁRenderFramebufferColor]
}

type binaryClassRenderFramebufferDepth struct{}

func (*RenderFramebufferDepth) Class() binary.Class {
	return (*binaryClassRenderFramebufferDepth)(nil)
}
func doEncodeRenderFramebufferDepth(e binary.Encoder, o *RenderFramebufferDepth) {
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
	e.Uint32(o.FramebufferWidth)
	e.Uint32(o.FramebufferHeight)
}
func doDecodeRenderFramebufferDepth(d binary.Decoder, o *RenderFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*path.Device)
	} else {
		o.Device = nil
	}
	if obj := d.Object(); obj != nil {
		o.After = obj.(*path.Atom)
	} else {
		o.After = nil
	}
	o.FramebufferWidth = uint32(d.Uint32())
	o.FramebufferHeight = uint32(d.Uint32())
}
func (*binaryClassRenderFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderFramebufferDepth(e, obj.(*RenderFramebufferDepth))
}
func (*binaryClassRenderFramebufferDepth) New() binary.Object {
	return &RenderFramebufferDepth{}
}
func (*binaryClassRenderFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderFramebufferDepth(d, obj.(*RenderFramebufferDepth))
}
func (c *binaryClassRenderFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁRenderFramebufferDepth]
}

type binaryClassSet struct{}

func (*Set) Class() binary.Class {
	return (*binaryClassSet)(nil)
}
func doEncodeSet(e binary.Encoder, o *Set) {
	e.Object(o.Path)
	schema.Any{}.EncodeValue(e, o.Value)
}
func doDecodeSet(d binary.Decoder, o *Set) {
	o.Path = path.PathCast(d.Object())
	o.Value = schema.Any{}.DecodeValue(d)
}
func (*binaryClassSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSet(e, obj.(*Set))
}
func (*binaryClassSet) New() binary.Object {
	return &Set{}
}
func (*binaryClassSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSet(d, obj.(*Set))
}
func (c *binaryClassSet) Schema() *binary.Entity {
	return &entities[ixǁSet]
}

type binaryClassatomFramebufferDimensions struct{}

func (*atomFramebufferDimensions) Class() binary.Class {
	return (*binaryClassatomFramebufferDimensions)(nil)
}
func doEncodeatomFramebufferDimensions(e binary.Writer, o *atomFramebufferDimensions) {
	e.Uint64(uint64(o.From))
	e.Uint32(o.Width)
	e.Uint32(o.Height)
}
func doDecodeatomFramebufferDimensions(d binary.Reader, o *atomFramebufferDimensions) {
	o.From = atom.ID(d.Uint64())
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
}
func (*binaryClassatomFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeatomFramebufferDimensions(e, obj.(*atomFramebufferDimensions))
}
func (*binaryClassatomFramebufferDimensions) New() binary.Object {
	return &atomFramebufferDimensions{}
}
func (*binaryClassatomFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeatomFramebufferDimensions(d, obj.(*atomFramebufferDimensions))
}
func (o *atomFramebufferDimensions) WriteSimple(w binary.Writer) {
	doEncodeatomFramebufferDimensions(w, o)
}
func (o *atomFramebufferDimensions) ReadSimple(r binary.Reader) {
	doDecodeatomFramebufferDimensions(r, o)
}
func (c *binaryClassatomFramebufferDimensions) Schema() *binary.Entity {
	return &entities[ixǁatomFramebufferDimensions]
}

type binaryClasscalcIndexLimits struct{}

func (*calcIndexLimits) Class() binary.Class {
	return (*binaryClasscalcIndexLimits)(nil)
}
func doEncodecalcIndexLimits(e binary.Writer, o *calcIndexLimits) {
	e.Int32(int32(o.indexSize))
	e.Int32(int32(o.count))
	e.Bool(o.littleEndian)
	e.Data(o.data[:20])
}
func doDecodecalcIndexLimits(d binary.Reader, o *calcIndexLimits) {
	o.indexSize = int(d.Int32())
	o.count = int(d.Int32())
	o.littleEndian = bool(d.Bool())
	d.Data(o.data[:20])
}
func (*binaryClasscalcIndexLimits) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecalcIndexLimits(e, obj.(*calcIndexLimits))
}
func (*binaryClasscalcIndexLimits) New() binary.Object {
	return &calcIndexLimits{}
}
func (*binaryClasscalcIndexLimits) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecalcIndexLimits(d, obj.(*calcIndexLimits))
}
func (o *calcIndexLimits) WriteSimple(w binary.Writer) {
	doEncodecalcIndexLimits(w, o)
}
func (o *calcIndexLimits) ReadSimple(r binary.Reader) {
	doDecodecalcIndexLimits(r, o)
}
func (c *binaryClasscalcIndexLimits) Schema() *binary.Entity {
	return &entities[ixǁcalcIndexLimits]
}

type binaryClasscaptureFramebufferDimensions struct{}

func (*captureFramebufferDimensions) Class() binary.Class {
	return (*binaryClasscaptureFramebufferDimensions)(nil)
}
func doEncodecaptureFramebufferDimensions(e binary.Writer, o *captureFramebufferDimensions) {
	e.Uint32(uint32(len(o.Dimensions)))
	for i := range o.Dimensions {
		curr := &o.Dimensions[i]
		e.Simple(&(*curr))
	}
}
func doDecodecaptureFramebufferDimensions(d binary.Reader, o *captureFramebufferDimensions) {
	if count := d.Count(); count > 0 {
		o.Dimensions = make([]atomFramebufferDimensions, count)
		for i := range o.Dimensions {
			curr := &o.Dimensions[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClasscaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecaptureFramebufferDimensions(e, obj.(*captureFramebufferDimensions))
}
func (*binaryClasscaptureFramebufferDimensions) New() binary.Object {
	return &captureFramebufferDimensions{}
}
func (*binaryClasscaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecaptureFramebufferDimensions(d, obj.(*captureFramebufferDimensions))
}
func (o *captureFramebufferDimensions) WriteSimple(w binary.Writer) {
	doEncodecaptureFramebufferDimensions(w, o)
}
func (o *captureFramebufferDimensions) ReadSimple(r binary.Reader) {
	doDecodecaptureFramebufferDimensions(r, o)
}
func (c *binaryClasscaptureFramebufferDimensions) Schema() *binary.Entity {
	return &entities[ixǁcaptureFramebufferDimensions]
}

type binaryClassgetCaptureFramebufferDimensions struct{}

func (*getCaptureFramebufferDimensions) Class() binary.Class {
	return (*binaryClassgetCaptureFramebufferDimensions)(nil)
}
func doEncodegetCaptureFramebufferDimensions(e binary.Encoder, o *getCaptureFramebufferDimensions) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodegetCaptureFramebufferDimensions(d binary.Decoder, o *getCaptureFramebufferDimensions) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*path.Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassgetCaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) {
	doEncodegetCaptureFramebufferDimensions(e, obj.(*getCaptureFramebufferDimensions))
}
func (*binaryClassgetCaptureFramebufferDimensions) New() binary.Object {
	return &getCaptureFramebufferDimensions{}
}
func (*binaryClassgetCaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodegetCaptureFramebufferDimensions(d, obj.(*getCaptureFramebufferDimensions))
}
func (c *binaryClassgetCaptureFramebufferDimensions) Schema() *binary.Entity {
	return &entities[ixǁgetCaptureFramebufferDimensions]
}