| //////////////////////////////////////////////////////////////////////////////// |
| // 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{0xd0, 0x7e, 0x58, 0xd4, 0xf5, 0xd8, 0x9f, 0x1d, 0xe4, 0xb5, 0xfe, 0x9d, 0xe6, 0x9c, 0xe4, 0x5c, 0xef, 0x0b, 0xfc, 0x71} |
| 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.Bool(o.Wireframe); 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.Bool(); err != nil { |
| return err |
| } else { |
| o.Wireframe = bool(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.Bool(); 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: "Wireframe", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| }, |
| } |
| |
| 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()}}}, |
| }, |
| } |