service/service_binary.go

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

package service

import (
	"fmt"

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

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*AtomRangeTimer)(nil).Class())
	Namespace.Add((*AtomTimer)(nil).Class())
	Namespace.Add((*Capture)(nil).Class())
	Namespace.Add((*Device)(nil).Class())
	Namespace.Add((*MemoryInfo)(nil).Class())
	Namespace.Add((*RenderSettings)(nil).Class())
	Namespace.Add((*ReportItem)(nil).Class())
	Namespace.Add((*Report)(nil).Class())
	Namespace.Add((*ResourceInfo)(nil).Class())
	Namespace.Add((*Resources)(nil).Class())
	Namespace.Add((*TimingInfo)(nil).Class())
	Namespace.Add((*callFollow)(nil).Class())
	Namespace.Add((*callGet)(nil).Class())
	Namespace.Add((*callGetCaptures)(nil).Class())
	Namespace.Add((*callGetDevices)(nil).Class())
	Namespace.Add((*callGetFramebufferColor)(nil).Class())
	Namespace.Add((*callGetFramebufferDepth)(nil).Class())
	Namespace.Add((*callGetSchema)(nil).Class())
	Namespace.Add((*callGetTimingInfo)(nil).Class())
	Namespace.Add((*callImportCapture)(nil).Class())
	Namespace.Add((*callLoadCapture)(nil).Class())
	Namespace.Add((*callSet)(nil).Class())
	Namespace.Add((*resultFollow)(nil).Class())
	Namespace.Add((*resultGet)(nil).Class())
	Namespace.Add((*resultGetCaptures)(nil).Class())
	Namespace.Add((*resultGetDevices)(nil).Class())
	Namespace.Add((*resultGetFramebufferColor)(nil).Class())
	Namespace.Add((*resultGetFramebufferDepth)(nil).Class())
	Namespace.Add((*resultGetSchema)(nil).Class())
	Namespace.Add((*resultGetTimingInfo)(nil).Class())
	Namespace.Add((*resultImportCapture)(nil).Class())
	Namespace.Add((*resultLoadCapture)(nil).Class())
	Namespace.Add((*resultSet)(nil).Class())
}

type binaryClassAtomRangeTimer struct{}

func (*AtomRangeTimer) Class() binary.Class {
	return (*binaryClassAtomRangeTimer)(nil)
}
func doEncodeAtomRangeTimer(e binary.Encoder, o *AtomRangeTimer) {
	e.Uint64(o.FromAtomIndex)
	e.Uint64(o.ToAtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomRangeTimer(d binary.Decoder, o *AtomRangeTimer) {
	o.FromAtomIndex = uint64(d.Uint64())
	o.ToAtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) New() binary.Object {
	return &AtomRangeTimer{}
}
func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) Schema() *binary.Entity { return schemaAtomRangeTimer }

var schemaAtomRangeTimer = &binary.Entity{
	Package:  "service",
	Identity: "AtomRangeTimer",
	Fields: []binary.Field{
		{Declared: "FromAtomIndex", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "ToAtomIndex", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassAtomTimer struct{}

func (*AtomTimer) Class() binary.Class {
	return (*binaryClassAtomTimer)(nil)
}
func doEncodeAtomTimer(e binary.Encoder, o *AtomTimer) {
	e.Uint64(o.AtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomTimer(d binary.Decoder, o *AtomTimer) {
	o.AtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomTimer(e, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) New() binary.Object {
	return &AtomTimer{}
}
func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomTimer(d, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) Schema() *binary.Entity { return schemaAtomTimer }

var schemaAtomTimer = &binary.Entity{
	Package:  "service",
	Identity: "AtomTimer",
	Fields: []binary.Field{
		{Declared: "AtomIndex", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Encoder, o *Capture) {
	e.String(o.Name)
	e.Data(o.Atoms[:20])
	e.Uint32(uint32(len(o.Apis)))
	for i := range o.Apis {
		curr := &o.Apis[i]
		e.Data((*curr)[:20])
	}
}
func doDecodeCapture(d binary.Decoder, o *Capture) {
	o.Name = string(d.String())
	d.Data(o.Atoms[:20])
	if count := d.Count(); count > 0 {
		o.Apis = make([]ApiID, count)
		for i := range o.Apis {
			curr := &o.Apis[i]
			d.Data((*curr)[:20])
		}
	}
}
func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCapture(e, obj.(*Capture))
}
func (*binaryClassCapture) New() binary.Object {
	return &Capture{}
}
func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCapture(d, obj.(*Capture))
}
func (*binaryClassCapture) Schema() *binary.Entity { return schemaCapture }

var schemaCapture = &binary.Entity{
	Package:  "service",
	Identity: "Capture",
	Fields: []binary.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Atoms", Type: &schema.Array{Alias: "AtomsID", ValueType: &schema.Primitive{Name: "byte", Method: schema.Uint8}, Size: 20}},
		{Declared: "Apis", Type: &schema.Slice{Alias: "", ValueType: &schema.Array{Alias: "ApiID", ValueType: &schema.Primitive{Name: "byte", Method: schema.Uint8}, Size: 20}}},
	},
}

type binaryClassDevice struct{}

func (*Device) Class() binary.Class {
	return (*binaryClassDevice)(nil)
}
func doEncodeDevice(e binary.Encoder, o *Device) {
	e.String(o.Name)
	e.String(o.Model)
	e.String(o.OS)
	e.Uint8(o.PointerSize)
	e.Uint8(o.PointerAlignment)
	e.Uint64(o.MaxMemorySize)
	e.String(o.Extensions)
	e.String(o.Renderer)
	e.String(o.Vendor)
	e.String(o.Version)
}
func doDecodeDevice(d binary.Decoder, o *Device) {
	o.Name = string(d.String())
	o.Model = string(d.String())
	o.OS = string(d.String())
	o.PointerSize = uint8(d.Uint8())
	o.PointerAlignment = uint8(d.Uint8())
	o.MaxMemorySize = uint64(d.Uint64())
	o.Extensions = string(d.String())
	o.Renderer = string(d.String())
	o.Vendor = string(d.String())
	o.Version = string(d.String())
}
func (*binaryClassDevice) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDevice(e, obj.(*Device))
}
func (*binaryClassDevice) New() binary.Object {
	return &Device{}
}
func (*binaryClassDevice) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDevice(d, obj.(*Device))
}
func (*binaryClassDevice) Schema() *binary.Entity { return schemaDevice }

var schemaDevice = &binary.Entity{
	Package:  "service",
	Identity: "Device",
	Fields: []binary.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Model", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "OS", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "PointerSize", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		{Declared: "PointerAlignment", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		{Declared: "MaxMemorySize", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Extensions", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Renderer", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Vendor", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Version", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassMemoryInfo struct{}

func (*MemoryInfo) Class() binary.Class {
	return (*binaryClassMemoryInfo)(nil)
}
func doEncodeMemoryInfo(e binary.Encoder, o *MemoryInfo) {
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
	e.Uint32(uint32(len(o.Reads)))
	for i := range o.Reads {
		curr := &o.Reads[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Writes)))
	for i := range o.Writes {
		curr := &o.Writes[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Observed)))
	for i := range o.Observed {
		curr := &o.Observed[i]
		e.Struct(&(*curr))
	}
}
func doDecodeMemoryInfo(d binary.Decoder, o *MemoryInfo) {
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
	if count := d.Count(); count > 0 {
		o.Reads = make(memory.RangeList, count)
		for i := range o.Reads {
			curr := &o.Reads[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Writes = make(memory.RangeList, count)
		for i := range o.Writes {
			curr := &o.Writes[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Observed = make(memory.RangeList, count)
		for i := range o.Observed {
			curr := &o.Observed[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMemoryInfo(e, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) New() binary.Object {
	return &MemoryInfo{}
}
func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMemoryInfo(d, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) Schema() *binary.Entity { return schemaMemoryInfo }

var schemaMemoryInfo = &binary.Entity{
	Package:  "service",
	Identity: "MemoryInfo",
	Fields: []binary.Field{
		{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
		{Declared: "Reads", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Entity: (*memory.Range)(nil).Class().Schema()}}},
		{Declared: "Writes", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Entity: (*memory.Range)(nil).Class().Schema()}}},
		{Declared: "Observed", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Entity: (*memory.Range)(nil).Class().Schema()}}},
	},
}

type binaryClassRenderSettings struct{}

func (*RenderSettings) Class() binary.Class {
	return (*binaryClassRenderSettings)(nil)
}
func doEncodeRenderSettings(e binary.Encoder, o *RenderSettings) {
	e.Uint32(o.MaxWidth)
	e.Uint32(o.MaxHeight)
	e.Int32(int32(o.WireframeMode))
}
func doDecodeRenderSettings(d binary.Decoder, o *RenderSettings) {
	o.MaxWidth = uint32(d.Uint32())
	o.MaxHeight = uint32(d.Uint32())
	o.WireframeMode = WireframeMode(d.Int32())
}
func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderSettings(e, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) New() binary.Object {
	return &RenderSettings{}
}
func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderSettings(d, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) Schema() *binary.Entity { return schemaRenderSettings }

var schemaRenderSettings = &binary.Entity{
	Package:  "service",
	Identity: "RenderSettings",
	Fields: []binary.Field{
		{Declared: "MaxWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "MaxHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "WireframeMode", Type: &schema.Primitive{Name: "WireframeMode", Method: schema.Int32}},
	},
}

type binaryClassReportItem struct{}

func (*ReportItem) Class() binary.Class {
	return (*binaryClassReportItem)(nil)
}
func doEncodeReportItem(e binary.Encoder, o *ReportItem) {
	e.Int32(int32(o.Severity))
	e.String(o.Message)
	e.Uint64(o.Atom)
}
func doDecodeReportItem(d binary.Decoder, o *ReportItem) {
	o.Severity = log.Severity(d.Int32())
	o.Message = string(d.String())
	o.Atom = uint64(d.Uint64())
}
func (*binaryClassReportItem) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReportItem(e, obj.(*ReportItem))
}
func (*binaryClassReportItem) New() binary.Object {
	return &ReportItem{}
}
func (*binaryClassReportItem) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReportItem(d, obj.(*ReportItem))
}
func (*binaryClassReportItem) Schema() *binary.Entity { return schemaReportItem }

var schemaReportItem = &binary.Entity{
	Package:  "service",
	Identity: "ReportItem",
	Fields: []binary.Field{
		{Declared: "Severity", Type: &schema.Primitive{Name: "log.Severity", Method: schema.Int32}},
		{Declared: "Message", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Atom", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassReport struct{}

func (*Report) Class() binary.Class {
	return (*binaryClassReport)(nil)
}
func doEncodeReport(e binary.Encoder, o *Report) {
	e.Uint32(uint32(len(o.Items)))
	for i := range o.Items {
		curr := &o.Items[i]
		e.Struct(&(*curr))
	}
}
func doDecodeReport(d binary.Decoder, o *Report) {
	if count := d.Count(); count > 0 {
		o.Items = make([]ReportItem, count)
		for i := range o.Items {
			curr := &o.Items[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassReport) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReport(e, obj.(*Report))
}
func (*binaryClassReport) New() binary.Object {
	return &Report{}
}
func (*binaryClassReport) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReport(d, obj.(*Report))
}
func (*binaryClassReport) Schema() *binary.Entity { return schemaReport }

var schemaReport = &binary.Entity{
	Package:  "service",
	Identity: "Report",
	Fields: []binary.Field{
		{Declared: "Items", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*ReportItem)(nil).Class().Schema()}}},
	},
}

type binaryClassResourceInfo struct{}

func (*ResourceInfo) Class() binary.Class {
	return (*binaryClassResourceInfo)(nil)
}
func doEncodeResourceInfo(e binary.Encoder, o *ResourceInfo) {
	e.Data(o.ID[:20])
	e.String(o.Name)
	e.Uint32(uint32(len(o.Accesses)))
	for i := range o.Accesses {
		curr := &o.Accesses[i]
		e.Uint64(*curr)
	}
}
func doDecodeResourceInfo(d binary.Decoder, o *ResourceInfo) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Accesses = make([]uint64, count)
		for i := range o.Accesses {
			curr := &o.Accesses[i]
			*curr = uint64(d.Uint64())
		}
	}
}
func (*binaryClassResourceInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceInfo(e, obj.(*ResourceInfo))
}
func (*binaryClassResourceInfo) New() binary.Object {
	return &ResourceInfo{}
}
func (*binaryClassResourceInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceInfo(d, obj.(*ResourceInfo))
}
func (*binaryClassResourceInfo) Schema() *binary.Entity { return schemaResourceInfo }

var schemaResourceInfo = &binary.Entity{
	Package:  "service",
	Identity: "ResourceInfo",
	Fields: []binary.Field{
		{Declared: "ID", Type: &schema.Array{Alias: "path.ResourceID", ValueType: &schema.Primitive{Name: "byte", Method: schema.Uint8}, Size: 20}},
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Accesses", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}},
	},
}

type binaryClassResources struct{}

func (*Resources) Class() binary.Class {
	return (*binaryClassResources)(nil)
}
func doEncodeResources(e binary.Encoder, o *Resources) {
	e.Uint32(uint32(len(o.Textures1D)))
	for i := range o.Textures1D {
		curr := &o.Textures1D[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures2D)))
	for i := range o.Textures2D {
		curr := &o.Textures2D[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures3D)))
	for i := range o.Textures3D {
		curr := &o.Textures3D[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Cubemaps)))
	for i := range o.Cubemaps {
		curr := &o.Cubemaps[i]
		e.Struct(&(*curr))
	}
}
func doDecodeResources(d binary.Decoder, o *Resources) {
	if count := d.Count(); count > 0 {
		o.Textures1D = make([]ResourceInfo, count)
		for i := range o.Textures1D {
			curr := &o.Textures1D[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures2D = make([]ResourceInfo, count)
		for i := range o.Textures2D {
			curr := &o.Textures2D[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures3D = make([]ResourceInfo, count)
		for i := range o.Textures3D {
			curr := &o.Textures3D[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemaps = make([]ResourceInfo, count)
		for i := range o.Cubemaps {
			curr := &o.Cubemaps[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassResources) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResources(e, obj.(*Resources))
}
func (*binaryClassResources) New() binary.Object {
	return &Resources{}
}
func (*binaryClassResources) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResources(d, obj.(*Resources))
}
func (*binaryClassResources) Schema() *binary.Entity { return schemaResources }

var schemaResources = &binary.Entity{
	Package:  "service",
	Identity: "Resources",
	Fields: []binary.Field{
		{Declared: "Textures1D", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*ResourceInfo)(nil).Class().Schema()}}},
		{Declared: "Textures2D", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*ResourceInfo)(nil).Class().Schema()}}},
		{Declared: "Textures3D", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*ResourceInfo)(nil).Class().Schema()}}},
		{Declared: "Cubemaps", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*ResourceInfo)(nil).Class().Schema()}}},
	},
}

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Encoder, o *TimingInfo) {
	e.Uint32(uint32(len(o.PerCommand)))
	for i := range o.PerCommand {
		curr := &o.PerCommand[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.PerDrawCall)))
	for i := range o.PerDrawCall {
		curr := &o.PerDrawCall[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.PerFrame)))
	for i := range o.PerFrame {
		curr := &o.PerFrame[i]
		e.Struct(&(*curr))
	}
}
func doDecodeTimingInfo(d binary.Decoder, o *TimingInfo) {
	if count := d.Count(); count > 0 {
		o.PerCommand = make([]AtomTimer, count)
		for i := range o.PerCommand {
			curr := &o.PerCommand[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerDrawCall = make([]AtomRangeTimer, count)
		for i := range o.PerDrawCall {
			curr := &o.PerDrawCall[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerFrame = make([]AtomRangeTimer, count)
		for i := range o.PerFrame {
			curr := &o.PerFrame[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTimingInfo(e, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) New() binary.Object {
	return &TimingInfo{}
}
func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTimingInfo(d, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) Schema() *binary.Entity { return schemaTimingInfo }

var schemaTimingInfo = &binary.Entity{
	Package:  "service",
	Identity: "TimingInfo",
	Fields: []binary.Field{
		{Declared: "PerCommand", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*AtomTimer)(nil).Class().Schema()}}},
		{Declared: "PerDrawCall", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*AtomRangeTimer)(nil).Class().Schema()}}},
		{Declared: "PerFrame", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Entity: (*AtomRangeTimer)(nil).Class().Schema()}}},
	},
}

type binaryClasscallFollow struct{}

func (*callFollow) Class() binary.Class {
	return (*binaryClasscallFollow)(nil)
}
func doEncodecallFollow(e binary.Encoder, o *callFollow) {
	e.Object(o.p)
}
func doDecodecallFollow(d binary.Decoder, o *callFollow) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallFollow(e, obj.(*callFollow))
}
func (*binaryClasscallFollow) New() binary.Object {
	return &callFollow{}
}
func (*binaryClasscallFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallFollow(d, obj.(*callFollow))
}
func (*binaryClasscallFollow) Schema() *binary.Entity { return schemacallFollow }

var schemacallFollow = &binary.Entity{
	Package:  "service",
	Identity: "callFollow",
	Fields: []binary.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClasscallGet struct{}

func (*callGet) Class() binary.Class {
	return (*binaryClasscallGet)(nil)
}
func doEncodecallGet(e binary.Encoder, o *callGet) {
	e.Object(o.p)
}
func doDecodecallGet(d binary.Decoder, o *callGet) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGet(e, obj.(*callGet))
}
func (*binaryClasscallGet) New() binary.Object {
	return &callGet{}
}
func (*binaryClasscallGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGet(d, obj.(*callGet))
}
func (*binaryClasscallGet) Schema() *binary.Entity { return schemacallGet }

var schemacallGet = &binary.Entity{
	Package:  "service",
	Identity: "callGet",
	Fields: []binary.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClasscallGetCaptures struct{}

func (*callGetCaptures) Class() binary.Class {
	return (*binaryClasscallGetCaptures)(nil)
}
func doEncodecallGetCaptures(e binary.Encoder, o *callGetCaptures) {
}
func doDecodecallGetCaptures(d binary.Decoder, o *callGetCaptures) {
}
func (*binaryClasscallGetCaptures) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetCaptures(e, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) New() binary.Object {
	return &callGetCaptures{}
}
func (*binaryClasscallGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetCaptures(d, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) Schema() *binary.Entity { return schemacallGetCaptures }

var schemacallGetCaptures = &binary.Entity{
	Package:  "service",
	Identity: "callGetCaptures",
	Fields:   []binary.Field{},
}

type binaryClasscallGetDevices struct{}

func (*callGetDevices) Class() binary.Class {
	return (*binaryClasscallGetDevices)(nil)
}
func doEncodecallGetDevices(e binary.Encoder, o *callGetDevices) {
}
func doDecodecallGetDevices(d binary.Decoder, o *callGetDevices) {
}
func (*binaryClasscallGetDevices) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetDevices(e, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) New() binary.Object {
	return &callGetDevices{}
}
func (*binaryClasscallGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetDevices(d, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) Schema() *binary.Entity { return schemacallGetDevices }

var schemacallGetDevices = &binary.Entity{
	Package:  "service",
	Identity: "callGetDevices",
	Fields:   []binary.Field{},
}

type binaryClasscallGetFramebufferColor struct{}

func (*callGetFramebufferColor) Class() binary.Class {
	return (*binaryClasscallGetFramebufferColor)(nil)
}
func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) {
	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.Struct(&o.settings)
}
func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) {
	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.Struct(&o.settings)
}
func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) New() binary.Object {
	return &callGetFramebufferColor{}
}
func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) Schema() *binary.Entity {
	return schemacallGetFramebufferColor
}

var schemacallGetFramebufferColor = &binary.Entity{
	Package:  "service",
	Identity: "callGetFramebufferColor",
	Fields: []binary.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Device)(nil).Class().Schema()}}},
		{Declared: "after", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Atom)(nil).Class().Schema()}}},
		{Declared: "settings", Type: &schema.Struct{Entity: (*RenderSettings)(nil).Class().Schema()}},
	},
}

type binaryClasscallGetFramebufferDepth struct{}

func (*callGetFramebufferDepth) Class() binary.Class {
	return (*binaryClasscallGetFramebufferDepth)(nil)
}
func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) {
	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 doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) {
	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 (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) New() binary.Object {
	return &callGetFramebufferDepth{}
}
func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) Schema() *binary.Entity {
	return schemacallGetFramebufferDepth
}

var schemacallGetFramebufferDepth = &binary.Entity{
	Package:  "service",
	Identity: "callGetFramebufferDepth",
	Fields: []binary.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Device)(nil).Class().Schema()}}},
		{Declared: "after", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Atom)(nil).Class().Schema()}}},
	},
}

type binaryClasscallGetSchema struct{}

func (*callGetSchema) Class() binary.Class {
	return (*binaryClasscallGetSchema)(nil)
}
func doEncodecallGetSchema(e binary.Encoder, o *callGetSchema) {
}
func doDecodecallGetSchema(d binary.Decoder, o *callGetSchema) {
}
func (*binaryClasscallGetSchema) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetSchema(e, obj.(*callGetSchema))
}
func (*binaryClasscallGetSchema) New() binary.Object {
	return &callGetSchema{}
}
func (*binaryClasscallGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetSchema(d, obj.(*callGetSchema))
}
func (*binaryClasscallGetSchema) Schema() *binary.Entity { return schemacallGetSchema }

var schemacallGetSchema = &binary.Entity{
	Package:  "service",
	Identity: "callGetSchema",
	Fields:   []binary.Field{},
}

type binaryClasscallGetTimingInfo struct{}

func (*callGetTimingInfo) Class() binary.Class {
	return (*binaryClasscallGetTimingInfo)(nil)
}
func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) {
	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 doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) {
	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 = TimingFlags(d.Int32())
}
func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) New() binary.Object {
	return &callGetTimingInfo{}
}
func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) Schema() *binary.Entity { return schemacallGetTimingInfo }

var schemacallGetTimingInfo = &binary.Entity{
	Package:  "service",
	Identity: "callGetTimingInfo",
	Fields: []binary.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Device)(nil).Class().Schema()}}},
		{Declared: "capture", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Capture)(nil).Class().Schema()}}},
		{Declared: "flags", Type: &schema.Primitive{Name: "TimingFlags", Method: schema.Int32}},
	},
}

type binaryClasscallImportCapture struct{}

func (*callImportCapture) Class() binary.Class {
	return (*binaryClasscallImportCapture)(nil)
}
func doEncodecallImportCapture(e binary.Encoder, o *callImportCapture) {
	e.String(o.name)
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
}
func doDecodecallImportCapture(d binary.Decoder, o *callImportCapture) {
	o.name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
}
func (*binaryClasscallImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallImportCapture(e, obj.(*callImportCapture))
}
func (*binaryClasscallImportCapture) New() binary.Object {
	return &callImportCapture{}
}
func (*binaryClasscallImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallImportCapture(d, obj.(*callImportCapture))
}
func (*binaryClasscallImportCapture) Schema() *binary.Entity { return schemacallImportCapture }

var schemacallImportCapture = &binary.Entity{
	Package:  "service",
	Identity: "callImportCapture",
	Fields: []binary.Field{
		{Declared: "name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
	},
}

type binaryClasscallLoadCapture struct{}

func (*callLoadCapture) Class() binary.Class {
	return (*binaryClasscallLoadCapture)(nil)
}
func doEncodecallLoadCapture(e binary.Encoder, o *callLoadCapture) {
	e.String(o.path)
}
func doDecodecallLoadCapture(d binary.Decoder, o *callLoadCapture) {
	o.path = string(d.String())
}
func (*binaryClasscallLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallLoadCapture(e, obj.(*callLoadCapture))
}
func (*binaryClasscallLoadCapture) New() binary.Object {
	return &callLoadCapture{}
}
func (*binaryClasscallLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallLoadCapture(d, obj.(*callLoadCapture))
}
func (*binaryClasscallLoadCapture) Schema() *binary.Entity { return schemacallLoadCapture }

var schemacallLoadCapture = &binary.Entity{
	Package:  "service",
	Identity: "callLoadCapture",
	Fields: []binary.Field{
		{Declared: "path", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClasscallSet struct{}

func (*callSet) Class() binary.Class {
	return (*binaryClasscallSet)(nil)
}
func doEncodecallSet(e binary.Encoder, o *callSet) {
	e.Object(o.p)
	schema.Any{}.EncodeValue(e, o.v)
}
func doDecodecallSet(d binary.Decoder, o *callSet) {
	o.p = path.PathCast(d.Object())
	o.v = schema.Any{}.DecodeValue(d)
}
func (*binaryClasscallSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallSet(e, obj.(*callSet))
}
func (*binaryClasscallSet) New() binary.Object {
	return &callSet{}
}
func (*binaryClasscallSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallSet(d, obj.(*callSet))
}
func (*binaryClasscallSet) Schema() *binary.Entity { return schemacallSet }

var schemacallSet = &binary.Entity{
	Package:  "service",
	Identity: "callSet",
	Fields: []binary.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
		{Declared: "v", Type: &schema.Any{}},
	},
}

type binaryClassresultFollow struct{}

func (*resultFollow) Class() binary.Class {
	return (*binaryClassresultFollow)(nil)
}
func doEncoderesultFollow(e binary.Encoder, o *resultFollow) {
	e.Object(o.value)
}
func doDecoderesultFollow(d binary.Decoder, o *resultFollow) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultFollow(e, obj.(*resultFollow))
}
func (*binaryClassresultFollow) New() binary.Object {
	return &resultFollow{}
}
func (*binaryClassresultFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultFollow(d, obj.(*resultFollow))
}
func (*binaryClassresultFollow) Schema() *binary.Entity { return schemaresultFollow }

var schemaresultFollow = &binary.Entity{
	Package:  "service",
	Identity: "resultFollow",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClassresultGet struct{}

func (*resultGet) Class() binary.Class {
	return (*binaryClassresultGet)(nil)
}
func doEncoderesultGet(e binary.Encoder, o *resultGet) {
	schema.Any{}.EncodeValue(e, o.value)
}
func doDecoderesultGet(d binary.Decoder, o *resultGet) {
	o.value = schema.Any{}.DecodeValue(d)
}
func (*binaryClassresultGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGet(e, obj.(*resultGet))
}
func (*binaryClassresultGet) New() binary.Object {
	return &resultGet{}
}
func (*binaryClassresultGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGet(d, obj.(*resultGet))
}
func (*binaryClassresultGet) Schema() *binary.Entity { return schemaresultGet }

var schemaresultGet = &binary.Entity{
	Package:  "service",
	Identity: "resultGet",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Any{}},
	},
}

type binaryClassresultGetCaptures struct{}

func (*resultGetCaptures) Class() binary.Class {
	return (*binaryClassresultGetCaptures)(nil)
}
func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		if *curr != nil {
			e.Object(*curr)
		} else {
			e.Object(nil)
		}
	}
}
func doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Capture, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Capture)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetCaptures(e, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) New() binary.Object {
	return &resultGetCaptures{}
}
func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetCaptures(d, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) Schema() *binary.Entity { return schemaresultGetCaptures }

var schemaresultGetCaptures = &binary.Entity{
	Package:  "service",
	Identity: "resultGetCaptures",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Capture)(nil).Class().Schema()}}}},
	},
}

type binaryClassresultGetDevices struct{}

func (*resultGetDevices) Class() binary.Class {
	return (*binaryClassresultGetDevices)(nil)
}
func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		if *curr != nil {
			e.Object(*curr)
		} else {
			e.Object(nil)
		}
	}
}
func doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Device, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Device)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetDevices(e, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) New() binary.Object {
	return &resultGetDevices{}
}
func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetDevices(d, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) Schema() *binary.Entity { return schemaresultGetDevices }

var schemaresultGetDevices = &binary.Entity{
	Package:  "service",
	Identity: "resultGetDevices",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Device)(nil).Class().Schema()}}}},
	},
}

type binaryClassresultGetFramebufferColor struct{}

func (*resultGetFramebufferColor) Class() binary.Class {
	return (*binaryClassresultGetFramebufferColor)(nil)
}
func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) New() binary.Object {
	return &resultGetFramebufferColor{}
}
func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) Schema() *binary.Entity {
	return schemaresultGetFramebufferColor
}

var schemaresultGetFramebufferColor = &binary.Entity{
	Package:  "service",
	Identity: "resultGetFramebufferColor",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.ImageInfo)(nil).Class().Schema()}}},
	},
}

type binaryClassresultGetFramebufferDepth struct{}

func (*resultGetFramebufferDepth) Class() binary.Class {
	return (*binaryClassresultGetFramebufferDepth)(nil)
}
func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) New() binary.Object {
	return &resultGetFramebufferDepth{}
}
func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) Schema() *binary.Entity {
	return schemaresultGetFramebufferDepth
}

var schemaresultGetFramebufferDepth = &binary.Entity{
	Package:  "service",
	Identity: "resultGetFramebufferDepth",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.ImageInfo)(nil).Class().Schema()}}},
	},
}

type binaryClassresultGetSchema struct{}

func (*resultGetSchema) Class() binary.Class {
	return (*binaryClassresultGetSchema)(nil)
}
func doEncoderesultGetSchema(e binary.Encoder, o *resultGetSchema) {
	e.Struct(&o.value)
}
func doDecoderesultGetSchema(d binary.Decoder, o *resultGetSchema) {
	d.Struct(&o.value)
}
func (*binaryClassresultGetSchema) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetSchema(e, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) New() binary.Object {
	return &resultGetSchema{}
}
func (*binaryClassresultGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetSchema(d, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) Schema() *binary.Entity { return schemaresultGetSchema }

var schemaresultGetSchema = &binary.Entity{
	Package:  "service",
	Identity: "resultGetSchema",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Struct{Entity: (*schema.Message)(nil).Class().Schema()}},
	},
}

type binaryClassresultGetTimingInfo struct{}

func (*resultGetTimingInfo) Class() binary.Class {
	return (*binaryClassresultGetTimingInfo)(nil)
}
func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.TimingInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) New() binary.Object {
	return &resultGetTimingInfo{}
}
func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) Schema() *binary.Entity { return schemaresultGetTimingInfo }

var schemaresultGetTimingInfo = &binary.Entity{
	Package:  "service",
	Identity: "resultGetTimingInfo",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.TimingInfo)(nil).Class().Schema()}}},
	},
}

type binaryClassresultImportCapture struct{}

func (*resultImportCapture) Class() binary.Class {
	return (*binaryClassresultImportCapture)(nil)
}
func doEncoderesultImportCapture(e binary.Encoder, o *resultImportCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultImportCapture(d binary.Decoder, o *resultImportCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultImportCapture(e, obj.(*resultImportCapture))
}
func (*binaryClassresultImportCapture) New() binary.Object {
	return &resultImportCapture{}
}
func (*binaryClassresultImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultImportCapture(d, obj.(*resultImportCapture))
}
func (*binaryClassresultImportCapture) Schema() *binary.Entity { return schemaresultImportCapture }

var schemaresultImportCapture = &binary.Entity{
	Package:  "service",
	Identity: "resultImportCapture",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Capture)(nil).Class().Schema()}}},
	},
}

type binaryClassresultLoadCapture struct{}

func (*resultLoadCapture) Class() binary.Class {
	return (*binaryClassresultLoadCapture)(nil)
}
func doEncoderesultLoadCapture(e binary.Encoder, o *resultLoadCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultLoadCapture(d binary.Decoder, o *resultLoadCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultLoadCapture(e, obj.(*resultLoadCapture))
}
func (*binaryClassresultLoadCapture) New() binary.Object {
	return &resultLoadCapture{}
}
func (*binaryClassresultLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultLoadCapture(d, obj.(*resultLoadCapture))
}
func (*binaryClassresultLoadCapture) Schema() *binary.Entity { return schemaresultLoadCapture }

var schemaresultLoadCapture = &binary.Entity{
	Package:  "service",
	Identity: "resultLoadCapture",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Entity: (*path.Capture)(nil).Class().Schema()}}},
	},
}

type binaryClassresultSet struct{}

func (*resultSet) Class() binary.Class {
	return (*binaryClassresultSet)(nil)
}
func doEncoderesultSet(e binary.Encoder, o *resultSet) {
	e.Object(o.value)
}
func doDecoderesultSet(d binary.Decoder, o *resultSet) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultSet(e, obj.(*resultSet))
}
func (*binaryClassresultSet) New() binary.Object {
	return &resultSet{}
}
func (*binaryClassresultSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultSet(d, obj.(*resultSet))
}
func (*binaryClassresultSet) Schema() *binary.Entity { return schemaresultSet }

var schemaresultSet = &binary.Entity{
	Package:  "service",
	Identity: "resultSet",
	Fields: []binary.Field{
		{Declared: "value", Type: &schema.Interface{Name: "path.Path"}},
	},
}

var ConstantValues schema.Constants

var _TimingFlags_map = map[TimingFlags]string{}

func init() {
	_TimingFlags_cs := schema.ConstantSet{
		Type: &schema.Primitive{Name: "TimingFlags", Method: schema.Int32},
		Entries: []schema.Constant{
			{Name: "TimingCPU", Value: int32(0)},
			{Name: "TimingGPU", Value: int32(1)},
			{Name: "TimingPerCommand", Value: int32(2)},
			{Name: "TimingPerDrawCall", Value: int32(4)},
			{Name: "TimingPerFrame", Value: int32(8)},
		},
	}
	ConstantValues = append(ConstantValues, _TimingFlags_cs)
	for _, cv := range _TimingFlags_cs.Entries {
		_TimingFlags_map[TimingFlags(cv.Value.(int32))] = cv.Name
	}
}

func (v TimingFlags) String() string {
	if s, ok := _TimingFlags_map[v]; ok {
		return s
	}
	return fmt.Sprintf("TimingFlags(%d)", v)
}

func (v *TimingFlags) Parse(s string) error {
	for k, t := range _TimingFlags_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in TimingFlags", s)
}

var _WireframeMode_map = map[WireframeMode]string{}

func init() {
	_WireframeMode_cs := schema.ConstantSet{
		Type: &schema.Primitive{Name: "WireframeMode", Method: schema.Int32},
		Entries: []schema.Constant{
			{Name: "NoWireframe", Value: int32(0)},
			{Name: "WireframeOverlay", Value: int32(1)},
			{Name: "AllWireframe", Value: int32(2)},
		},
	}
	ConstantValues = append(ConstantValues, _WireframeMode_cs)
	for _, cv := range _WireframeMode_cs.Entries {
		_WireframeMode_map[WireframeMode(cv.Value.(int32))] = cv.Name
	}
}

func (v WireframeMode) String() string {
	if s, ok := _WireframeMode_map[v]; ok {
		return s
	}
	return fmt.Sprintf("WireframeMode(%d)", v)
}

func (v *WireframeMode) Parse(s string) error {
	for k, t := range _WireframeMode_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in WireframeMode", s)
}