gapid/image/image_binary.go

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

package image

import (
	"android.googlesource.com/platform/tools/gpu/framework/binary"
	"android.googlesource.com/platform/tools/gpu/framework/binary/registry"
	"android.googlesource.com/platform/tools/gpu/framework/id"
	"android.googlesource.com/platform/tools/gpu/gapid/service/path"
)

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

// force use the id package, because our imports handling is wrong
var _ id.ID

const (
	ixǁImage = iota
	ixǁInfo
	ixǁLazyConverter
	ixǁLazyResizer
	ixǁfmtATC_RGBA_EXPLICIT_ALPHA_AMD
	ixǁfmtATC_RGBA_INTERPOLATED_ALPHA_AMD
	ixǁfmtATC_RGB_AMD
	ixǁfmtAlpha
	ixǁfmtBGRA
	ixǁfmtD24S8
	ixǁfmtDF32S8
	ixǁfmtDepth16
	ixǁfmtDepthF16
	ixǁfmtDepthF32
	ixǁfmtETC1_RGB8
	ixǁfmtETC2_RGB8
	ixǁfmtETC2_RGBA8_EAC
	ixǁfmtFloat16
	ixǁfmtFloat32
	ixǁfmtLuminance
	ixǁfmtLuminanceAlpha
	ixǁfmtPNG
	ixǁfmtRG
	ixǁfmtRGB
	ixǁfmtRGB565
	ixǁfmtRGBA
	ixǁfmtRGBA1010102
	ixǁfmtRGBA4444
	ixǁfmtRGBA5551
	ixǁfmtRGBAF16
	ixǁfmtRGBAF32
	ixǁfmtRGBF16
	ixǁfmtRGBF32
	ixǁfmtRGF16
	ixǁfmtRGF32
	ixǁfmtRed
	ixǁfmtRedF16
	ixǁfmtRedF32
	ixǁfmtRedU16
	ixǁfmtS3_DXT1_RGB
	ixǁfmtS3_DXT1_RGBA
	ixǁfmtS3_DXT3_RGBA
	ixǁfmtS3_DXT5_RGBA
)

var entities [43]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*Image)(nil))
	Namespace.AddClassOf((*Info)(nil))
	Namespace.AddClassOf((*LazyConverter)(nil))
	Namespace.AddClassOf((*LazyResizer)(nil))
	Namespace.AddClassOf((*fmtATC_RGBA_EXPLICIT_ALPHA_AMD)(nil))
	Namespace.AddClassOf((*fmtATC_RGBA_INTERPOLATED_ALPHA_AMD)(nil))
	Namespace.AddClassOf((*fmtATC_RGB_AMD)(nil))
	Namespace.AddClassOf((*fmtAlpha)(nil))
	Namespace.AddClassOf((*fmtBGRA)(nil))
	Namespace.AddClassOf((*fmtD24S8)(nil))
	Namespace.AddClassOf((*fmtDF32S8)(nil))
	Namespace.AddClassOf((*fmtDepth16)(nil))
	Namespace.AddClassOf((*fmtDepthF16)(nil))
	Namespace.AddClassOf((*fmtDepthF32)(nil))
	Namespace.AddClassOf((*fmtETC1_RGB8)(nil))
	Namespace.AddClassOf((*fmtETC2_RGB8)(nil))
	Namespace.AddClassOf((*fmtETC2_RGBA8_EAC)(nil))
	Namespace.AddClassOf((*fmtFloat16)(nil))
	Namespace.AddClassOf((*fmtFloat32)(nil))
	Namespace.AddClassOf((*fmtLuminance)(nil))
	Namespace.AddClassOf((*fmtLuminanceAlpha)(nil))
	Namespace.AddClassOf((*fmtPNG)(nil))
	Namespace.AddClassOf((*fmtRG)(nil))
	Namespace.AddClassOf((*fmtRGB)(nil))
	Namespace.AddClassOf((*fmtRGB565)(nil))
	Namespace.AddClassOf((*fmtRGBA)(nil))
	Namespace.AddClassOf((*fmtRGBA1010102)(nil))
	Namespace.AddClassOf((*fmtRGBA4444)(nil))
	Namespace.AddClassOf((*fmtRGBA5551)(nil))
	Namespace.AddClassOf((*fmtRGBAF16)(nil))
	Namespace.AddClassOf((*fmtRGBAF32)(nil))
	Namespace.AddClassOf((*fmtRGBF16)(nil))
	Namespace.AddClassOf((*fmtRGBF32)(nil))
	Namespace.AddClassOf((*fmtRGF16)(nil))
	Namespace.AddClassOf((*fmtRGF32)(nil))
	Namespace.AddClassOf((*fmtRed)(nil))
	Namespace.AddClassOf((*fmtRedF16)(nil))
	Namespace.AddClassOf((*fmtRedF32)(nil))
	Namespace.AddClassOf((*fmtRedU16)(nil))
	Namespace.AddClassOf((*fmtS3_DXT1_RGB)(nil))
	Namespace.AddClassOf((*fmtS3_DXT1_RGBA)(nil))
	Namespace.AddClassOf((*fmtS3_DXT3_RGBA)(nil))
	Namespace.AddClassOf((*fmtS3_DXT5_RGBA)(nil))
}

type binaryClassImage struct{}

func (*Image) Class() binary.Class {
	return (*binaryClassImage)(nil)
}
func doEncodeImage(e binary.Encoder, o *Image) {
	e.Object(o.Format)
	e.Uint32(o.Width)
	e.Uint32(o.Height)
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
}
func doDecodeImage(d binary.Decoder, o *Image) {
	o.Format = FormatCast(d.Object())
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Data = make([]byte, count)
		d.Data(o.Data)
	}
}
func doDecodeRawImage(d binary.Decoder, o *Image) {
	o.Format = FormatCast(d.Object())
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Data = make([]byte, count)
		d.Data(o.Data)
	}
}
func (*binaryClassImage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeImage(e, obj.(*Image))
}
func (*binaryClassImage) New() binary.Object {
	return &Image{}
}
func (*binaryClassImage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeImage(d, obj.(*Image))
}
func (c *binaryClassImage) Schema() *binary.Entity {
	return &entities[ixǁImage]
}

type binaryClassInfo struct{}

func (*Info) Class() binary.Class {
	return (*binaryClassInfo)(nil)
}
func doEncodeInfo(e binary.Encoder, o *Info) {
	e.Object(o.Format)
	e.Uint32(o.Width)
	e.Uint32(o.Height)
	if o.Data != nil {
		e.Object(o.Data)
	} else {
		e.Object(nil)
	}
}
func doDecodeInfo(d binary.Decoder, o *Info) {
	o.Format = FormatCast(d.Object())
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	if obj := d.Object(); obj != nil {
		o.Data = obj.(*path.Blob)
	} else {
		o.Data = nil
	}
}
func doDecodeRawInfo(d binary.Decoder, o *Info) {
	o.Format = FormatCast(d.Object())
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	if obj := d.Object(); obj != nil {
		o.Data = obj.(*path.Blob)
	} else {
		o.Data = nil
	}
}
func (*binaryClassInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeInfo(e, obj.(*Info))
}
func (*binaryClassInfo) New() binary.Object {
	return &Info{}
}
func (*binaryClassInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeInfo(d, obj.(*Info))
}
func (c *binaryClassInfo) Schema() *binary.Entity {
	return &entities[ixǁInfo]
}

type binaryClassLazyConverter struct{}

func (*LazyConverter) Class() binary.Class {
	return (*binaryClassLazyConverter)(nil)
}
func doEncodeLazyConverter(e binary.Encoder, o *LazyConverter) {
	e.Data(o.Data[:20])
	e.Uint32(o.Width)
	e.Uint32(o.Height)
	e.Object(o.FormatFrom)
	e.Object(o.FormatTo)
	e.Int32(int32(o.StrideFrom))
}
func doDecodeLazyConverter(d binary.Decoder, o *LazyConverter) {
	d.Data(o.Data[:20])
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	o.FormatFrom = FormatCast(d.Object())
	o.FormatTo = FormatCast(d.Object())
	o.StrideFrom = int(d.Int32())
}
func doDecodeRawLazyConverter(d binary.Decoder, o *LazyConverter) {
	d.Data(o.Data[:20])
	o.Width = uint32(d.Uint32())
	o.Height = uint32(d.Uint32())
	o.FormatFrom = FormatCast(d.Object())
	o.FormatTo = FormatCast(d.Object())
	o.StrideFrom = int(d.Int32())
}
func (*binaryClassLazyConverter) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeLazyConverter(e, obj.(*LazyConverter))
}
func (*binaryClassLazyConverter) New() binary.Object {
	return &LazyConverter{}
}
func (*binaryClassLazyConverter) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeLazyConverter(d, obj.(*LazyConverter))
}
func (c *binaryClassLazyConverter) Schema() *binary.Entity {
	return &entities[ixǁLazyConverter]
}

type binaryClassLazyResizer struct{}

func (*LazyResizer) Class() binary.Class {
	return (*binaryClassLazyResizer)(nil)
}
func doEncodeLazyResizer(e binary.Encoder, o *LazyResizer) {
	e.Data(o.Data[:20])
	e.Object(o.Format)
	e.Uint32(o.SrcWidth)
	e.Uint32(o.SrcHeight)
	e.Uint32(o.DstWidth)
	e.Uint32(o.DstHeight)
}
func doDecodeLazyResizer(d binary.Decoder, o *LazyResizer) {
	d.Data(o.Data[:20])
	o.Format = FormatCast(d.Object())
	o.SrcWidth = uint32(d.Uint32())
	o.SrcHeight = uint32(d.Uint32())
	o.DstWidth = uint32(d.Uint32())
	o.DstHeight = uint32(d.Uint32())
}
func doDecodeRawLazyResizer(d binary.Decoder, o *LazyResizer) {
	d.Data(o.Data[:20])
	o.Format = FormatCast(d.Object())
	o.SrcWidth = uint32(d.Uint32())
	o.SrcHeight = uint32(d.Uint32())
	o.DstWidth = uint32(d.Uint32())
	o.DstHeight = uint32(d.Uint32())
}
func (*binaryClassLazyResizer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeLazyResizer(e, obj.(*LazyResizer))
}
func (*binaryClassLazyResizer) New() binary.Object {
	return &LazyResizer{}
}
func (*binaryClassLazyResizer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeLazyResizer(d, obj.(*LazyResizer))
}
func (c *binaryClassLazyResizer) Schema() *binary.Entity {
	return &entities[ixǁLazyResizer]
}

type binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD struct{}

func (*fmtATC_RGBA_EXPLICIT_ALPHA_AMD) Class() binary.Class {
	return (*binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD)(nil)
}
func doEncodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(e binary.Writer, o *fmtATC_RGBA_EXPLICIT_ALPHA_AMD) {
}
func doDecodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(d binary.Reader, o *fmtATC_RGBA_EXPLICIT_ALPHA_AMD) {
}
func doDecodeRawfmtATC_RGBA_EXPLICIT_ALPHA_AMD(d binary.Reader, o *fmtATC_RGBA_EXPLICIT_ALPHA_AMD) {
}
func (*binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(e, obj.(*fmtATC_RGBA_EXPLICIT_ALPHA_AMD))
}
func (*binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD) New() binary.Object {
	return &fmtATC_RGBA_EXPLICIT_ALPHA_AMD{}
}
func (*binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(d, obj.(*fmtATC_RGBA_EXPLICIT_ALPHA_AMD))
}
func (o *fmtATC_RGBA_EXPLICIT_ALPHA_AMD) WriteSimple(w binary.Writer) {
	doEncodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(w, o)
}
func (o *fmtATC_RGBA_EXPLICIT_ALPHA_AMD) ReadSimple(r binary.Reader) {
	doDecodefmtATC_RGBA_EXPLICIT_ALPHA_AMD(r, o)
}
func (c *binaryClassfmtATC_RGBA_EXPLICIT_ALPHA_AMD) Schema() *binary.Entity {
	return &entities[ixǁfmtATC_RGBA_EXPLICIT_ALPHA_AMD]
}

type binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD struct{}

func (*fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) Class() binary.Class {
	return (*binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD)(nil)
}
func doEncodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(e binary.Writer, o *fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) {
}
func doDecodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(d binary.Reader, o *fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) {
}
func doDecodeRawfmtATC_RGBA_INTERPOLATED_ALPHA_AMD(d binary.Reader, o *fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) {
}
func (*binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(e, obj.(*fmtATC_RGBA_INTERPOLATED_ALPHA_AMD))
}
func (*binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD) New() binary.Object {
	return &fmtATC_RGBA_INTERPOLATED_ALPHA_AMD{}
}
func (*binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(d, obj.(*fmtATC_RGBA_INTERPOLATED_ALPHA_AMD))
}
func (o *fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) WriteSimple(w binary.Writer) {
	doEncodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(w, o)
}
func (o *fmtATC_RGBA_INTERPOLATED_ALPHA_AMD) ReadSimple(r binary.Reader) {
	doDecodefmtATC_RGBA_INTERPOLATED_ALPHA_AMD(r, o)
}
func (c *binaryClassfmtATC_RGBA_INTERPOLATED_ALPHA_AMD) Schema() *binary.Entity {
	return &entities[ixǁfmtATC_RGBA_INTERPOLATED_ALPHA_AMD]
}

type binaryClassfmtATC_RGB_AMD struct{}

func (*fmtATC_RGB_AMD) Class() binary.Class {
	return (*binaryClassfmtATC_RGB_AMD)(nil)
}
func doEncodefmtATC_RGB_AMD(e binary.Writer, o *fmtATC_RGB_AMD) {
}
func doDecodefmtATC_RGB_AMD(d binary.Reader, o *fmtATC_RGB_AMD) {
}
func doDecodeRawfmtATC_RGB_AMD(d binary.Reader, o *fmtATC_RGB_AMD) {
}
func (*binaryClassfmtATC_RGB_AMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtATC_RGB_AMD(e, obj.(*fmtATC_RGB_AMD))
}
func (*binaryClassfmtATC_RGB_AMD) New() binary.Object {
	return &fmtATC_RGB_AMD{}
}
func (*binaryClassfmtATC_RGB_AMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtATC_RGB_AMD(d, obj.(*fmtATC_RGB_AMD))
}
func (o *fmtATC_RGB_AMD) WriteSimple(w binary.Writer) {
	doEncodefmtATC_RGB_AMD(w, o)
}
func (o *fmtATC_RGB_AMD) ReadSimple(r binary.Reader) {
	doDecodefmtATC_RGB_AMD(r, o)
}
func (c *binaryClassfmtATC_RGB_AMD) Schema() *binary.Entity {
	return &entities[ixǁfmtATC_RGB_AMD]
}

type binaryClassfmtAlpha struct{}

func (*fmtAlpha) Class() binary.Class {
	return (*binaryClassfmtAlpha)(nil)
}
func doEncodefmtAlpha(e binary.Writer, o *fmtAlpha) {
}
func doDecodefmtAlpha(d binary.Reader, o *fmtAlpha) {
}
func doDecodeRawfmtAlpha(d binary.Reader, o *fmtAlpha) {
}
func (*binaryClassfmtAlpha) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtAlpha(e, obj.(*fmtAlpha))
}
func (*binaryClassfmtAlpha) New() binary.Object {
	return &fmtAlpha{}
}
func (*binaryClassfmtAlpha) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtAlpha(d, obj.(*fmtAlpha))
}
func (o *fmtAlpha) WriteSimple(w binary.Writer) {
	doEncodefmtAlpha(w, o)
}
func (o *fmtAlpha) ReadSimple(r binary.Reader) {
	doDecodefmtAlpha(r, o)
}
func (c *binaryClassfmtAlpha) Schema() *binary.Entity {
	return &entities[ixǁfmtAlpha]
}

type binaryClassfmtBGRA struct{}

func (*fmtBGRA) Class() binary.Class {
	return (*binaryClassfmtBGRA)(nil)
}
func doEncodefmtBGRA(e binary.Writer, o *fmtBGRA) {
}
func doDecodefmtBGRA(d binary.Reader, o *fmtBGRA) {
}
func doDecodeRawfmtBGRA(d binary.Reader, o *fmtBGRA) {
}
func (*binaryClassfmtBGRA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtBGRA(e, obj.(*fmtBGRA))
}
func (*binaryClassfmtBGRA) New() binary.Object {
	return &fmtBGRA{}
}
func (*binaryClassfmtBGRA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtBGRA(d, obj.(*fmtBGRA))
}
func (o *fmtBGRA) WriteSimple(w binary.Writer) {
	doEncodefmtBGRA(w, o)
}
func (o *fmtBGRA) ReadSimple(r binary.Reader) {
	doDecodefmtBGRA(r, o)
}
func (c *binaryClassfmtBGRA) Schema() *binary.Entity {
	return &entities[ixǁfmtBGRA]
}

type binaryClassfmtD24S8 struct{}

func (*fmtD24S8) Class() binary.Class {
	return (*binaryClassfmtD24S8)(nil)
}
func doEncodefmtD24S8(e binary.Writer, o *fmtD24S8) {
}
func doDecodefmtD24S8(d binary.Reader, o *fmtD24S8) {
}
func doDecodeRawfmtD24S8(d binary.Reader, o *fmtD24S8) {
}
func (*binaryClassfmtD24S8) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtD24S8(e, obj.(*fmtD24S8))
}
func (*binaryClassfmtD24S8) New() binary.Object {
	return &fmtD24S8{}
}
func (*binaryClassfmtD24S8) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtD24S8(d, obj.(*fmtD24S8))
}
func (o *fmtD24S8) WriteSimple(w binary.Writer) {
	doEncodefmtD24S8(w, o)
}
func (o *fmtD24S8) ReadSimple(r binary.Reader) {
	doDecodefmtD24S8(r, o)
}
func (c *binaryClassfmtD24S8) Schema() *binary.Entity {
	return &entities[ixǁfmtD24S8]
}

type binaryClassfmtDF32S8 struct{}

func (*fmtDF32S8) Class() binary.Class {
	return (*binaryClassfmtDF32S8)(nil)
}
func doEncodefmtDF32S8(e binary.Writer, o *fmtDF32S8) {
}
func doDecodefmtDF32S8(d binary.Reader, o *fmtDF32S8) {
}
func doDecodeRawfmtDF32S8(d binary.Reader, o *fmtDF32S8) {
}
func (*binaryClassfmtDF32S8) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtDF32S8(e, obj.(*fmtDF32S8))
}
func (*binaryClassfmtDF32S8) New() binary.Object {
	return &fmtDF32S8{}
}
func (*binaryClassfmtDF32S8) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtDF32S8(d, obj.(*fmtDF32S8))
}
func (o *fmtDF32S8) WriteSimple(w binary.Writer) {
	doEncodefmtDF32S8(w, o)
}
func (o *fmtDF32S8) ReadSimple(r binary.Reader) {
	doDecodefmtDF32S8(r, o)
}
func (c *binaryClassfmtDF32S8) Schema() *binary.Entity {
	return &entities[ixǁfmtDF32S8]
}

type binaryClassfmtDepth16 struct{}

func (*fmtDepth16) Class() binary.Class {
	return (*binaryClassfmtDepth16)(nil)
}
func doEncodefmtDepth16(e binary.Writer, o *fmtDepth16) {
}
func doDecodefmtDepth16(d binary.Reader, o *fmtDepth16) {
}
func doDecodeRawfmtDepth16(d binary.Reader, o *fmtDepth16) {
}
func (*binaryClassfmtDepth16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtDepth16(e, obj.(*fmtDepth16))
}
func (*binaryClassfmtDepth16) New() binary.Object {
	return &fmtDepth16{}
}
func (*binaryClassfmtDepth16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtDepth16(d, obj.(*fmtDepth16))
}
func (o *fmtDepth16) WriteSimple(w binary.Writer) {
	doEncodefmtDepth16(w, o)
}
func (o *fmtDepth16) ReadSimple(r binary.Reader) {
	doDecodefmtDepth16(r, o)
}
func (c *binaryClassfmtDepth16) Schema() *binary.Entity {
	return &entities[ixǁfmtDepth16]
}

type binaryClassfmtDepthF16 struct{}

func (*fmtDepthF16) Class() binary.Class {
	return (*binaryClassfmtDepthF16)(nil)
}
func doEncodefmtDepthF16(e binary.Writer, o *fmtDepthF16) {
}
func doDecodefmtDepthF16(d binary.Reader, o *fmtDepthF16) {
}
func doDecodeRawfmtDepthF16(d binary.Reader, o *fmtDepthF16) {
}
func (*binaryClassfmtDepthF16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtDepthF16(e, obj.(*fmtDepthF16))
}
func (*binaryClassfmtDepthF16) New() binary.Object {
	return &fmtDepthF16{}
}
func (*binaryClassfmtDepthF16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtDepthF16(d, obj.(*fmtDepthF16))
}
func (o *fmtDepthF16) WriteSimple(w binary.Writer) {
	doEncodefmtDepthF16(w, o)
}
func (o *fmtDepthF16) ReadSimple(r binary.Reader) {
	doDecodefmtDepthF16(r, o)
}
func (c *binaryClassfmtDepthF16) Schema() *binary.Entity {
	return &entities[ixǁfmtDepthF16]
}

type binaryClassfmtDepthF32 struct{}

func (*fmtDepthF32) Class() binary.Class {
	return (*binaryClassfmtDepthF32)(nil)
}
func doEncodefmtDepthF32(e binary.Writer, o *fmtDepthF32) {
}
func doDecodefmtDepthF32(d binary.Reader, o *fmtDepthF32) {
}
func doDecodeRawfmtDepthF32(d binary.Reader, o *fmtDepthF32) {
}
func (*binaryClassfmtDepthF32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtDepthF32(e, obj.(*fmtDepthF32))
}
func (*binaryClassfmtDepthF32) New() binary.Object {
	return &fmtDepthF32{}
}
func (*binaryClassfmtDepthF32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtDepthF32(d, obj.(*fmtDepthF32))
}
func (o *fmtDepthF32) WriteSimple(w binary.Writer) {
	doEncodefmtDepthF32(w, o)
}
func (o *fmtDepthF32) ReadSimple(r binary.Reader) {
	doDecodefmtDepthF32(r, o)
}
func (c *binaryClassfmtDepthF32) Schema() *binary.Entity {
	return &entities[ixǁfmtDepthF32]
}

type binaryClassfmtETC1_RGB8 struct{}

func (*fmtETC1_RGB8) Class() binary.Class {
	return (*binaryClassfmtETC1_RGB8)(nil)
}
func doEncodefmtETC1_RGB8(e binary.Writer, o *fmtETC1_RGB8) {
}
func doDecodefmtETC1_RGB8(d binary.Reader, o *fmtETC1_RGB8) {
}
func doDecodeRawfmtETC1_RGB8(d binary.Reader, o *fmtETC1_RGB8) {
}
func (*binaryClassfmtETC1_RGB8) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtETC1_RGB8(e, obj.(*fmtETC1_RGB8))
}
func (*binaryClassfmtETC1_RGB8) New() binary.Object {
	return &fmtETC1_RGB8{}
}
func (*binaryClassfmtETC1_RGB8) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtETC1_RGB8(d, obj.(*fmtETC1_RGB8))
}
func (o *fmtETC1_RGB8) WriteSimple(w binary.Writer) {
	doEncodefmtETC1_RGB8(w, o)
}
func (o *fmtETC1_RGB8) ReadSimple(r binary.Reader) {
	doDecodefmtETC1_RGB8(r, o)
}
func (c *binaryClassfmtETC1_RGB8) Schema() *binary.Entity {
	return &entities[ixǁfmtETC1_RGB8]
}

type binaryClassfmtETC2_RGB8 struct{}

func (*fmtETC2_RGB8) Class() binary.Class {
	return (*binaryClassfmtETC2_RGB8)(nil)
}
func doEncodefmtETC2_RGB8(e binary.Writer, o *fmtETC2_RGB8) {
}
func doDecodefmtETC2_RGB8(d binary.Reader, o *fmtETC2_RGB8) {
}
func doDecodeRawfmtETC2_RGB8(d binary.Reader, o *fmtETC2_RGB8) {
}
func (*binaryClassfmtETC2_RGB8) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtETC2_RGB8(e, obj.(*fmtETC2_RGB8))
}
func (*binaryClassfmtETC2_RGB8) New() binary.Object {
	return &fmtETC2_RGB8{}
}
func (*binaryClassfmtETC2_RGB8) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtETC2_RGB8(d, obj.(*fmtETC2_RGB8))
}
func (o *fmtETC2_RGB8) WriteSimple(w binary.Writer) {
	doEncodefmtETC2_RGB8(w, o)
}
func (o *fmtETC2_RGB8) ReadSimple(r binary.Reader) {
	doDecodefmtETC2_RGB8(r, o)
}
func (c *binaryClassfmtETC2_RGB8) Schema() *binary.Entity {
	return &entities[ixǁfmtETC2_RGB8]
}

type binaryClassfmtETC2_RGBA8_EAC struct{}

func (*fmtETC2_RGBA8_EAC) Class() binary.Class {
	return (*binaryClassfmtETC2_RGBA8_EAC)(nil)
}
func doEncodefmtETC2_RGBA8_EAC(e binary.Writer, o *fmtETC2_RGBA8_EAC) {
}
func doDecodefmtETC2_RGBA8_EAC(d binary.Reader, o *fmtETC2_RGBA8_EAC) {
}
func doDecodeRawfmtETC2_RGBA8_EAC(d binary.Reader, o *fmtETC2_RGBA8_EAC) {
}
func (*binaryClassfmtETC2_RGBA8_EAC) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtETC2_RGBA8_EAC(e, obj.(*fmtETC2_RGBA8_EAC))
}
func (*binaryClassfmtETC2_RGBA8_EAC) New() binary.Object {
	return &fmtETC2_RGBA8_EAC{}
}
func (*binaryClassfmtETC2_RGBA8_EAC) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtETC2_RGBA8_EAC(d, obj.(*fmtETC2_RGBA8_EAC))
}
func (o *fmtETC2_RGBA8_EAC) WriteSimple(w binary.Writer) {
	doEncodefmtETC2_RGBA8_EAC(w, o)
}
func (o *fmtETC2_RGBA8_EAC) ReadSimple(r binary.Reader) {
	doDecodefmtETC2_RGBA8_EAC(r, o)
}
func (c *binaryClassfmtETC2_RGBA8_EAC) Schema() *binary.Entity {
	return &entities[ixǁfmtETC2_RGBA8_EAC]
}

type binaryClassfmtFloat16 struct{}

func (*fmtFloat16) Class() binary.Class {
	return (*binaryClassfmtFloat16)(nil)
}
func doEncodefmtFloat16(e binary.Writer, o *fmtFloat16) {
}
func doDecodefmtFloat16(d binary.Reader, o *fmtFloat16) {
}
func doDecodeRawfmtFloat16(d binary.Reader, o *fmtFloat16) {
}
func (*binaryClassfmtFloat16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtFloat16(e, obj.(*fmtFloat16))
}
func (*binaryClassfmtFloat16) New() binary.Object {
	return &fmtFloat16{}
}
func (*binaryClassfmtFloat16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtFloat16(d, obj.(*fmtFloat16))
}
func (o *fmtFloat16) WriteSimple(w binary.Writer) {
	doEncodefmtFloat16(w, o)
}
func (o *fmtFloat16) ReadSimple(r binary.Reader) {
	doDecodefmtFloat16(r, o)
}
func (c *binaryClassfmtFloat16) Schema() *binary.Entity {
	return &entities[ixǁfmtFloat16]
}

type binaryClassfmtFloat32 struct{}

func (*fmtFloat32) Class() binary.Class {
	return (*binaryClassfmtFloat32)(nil)
}
func doEncodefmtFloat32(e binary.Writer, o *fmtFloat32) {
}
func doDecodefmtFloat32(d binary.Reader, o *fmtFloat32) {
}
func doDecodeRawfmtFloat32(d binary.Reader, o *fmtFloat32) {
}
func (*binaryClassfmtFloat32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtFloat32(e, obj.(*fmtFloat32))
}
func (*binaryClassfmtFloat32) New() binary.Object {
	return &fmtFloat32{}
}
func (*binaryClassfmtFloat32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtFloat32(d, obj.(*fmtFloat32))
}
func (o *fmtFloat32) WriteSimple(w binary.Writer) {
	doEncodefmtFloat32(w, o)
}
func (o *fmtFloat32) ReadSimple(r binary.Reader) {
	doDecodefmtFloat32(r, o)
}
func (c *binaryClassfmtFloat32) Schema() *binary.Entity {
	return &entities[ixǁfmtFloat32]
}

type binaryClassfmtLuminance struct{}

func (*fmtLuminance) Class() binary.Class {
	return (*binaryClassfmtLuminance)(nil)
}
func doEncodefmtLuminance(e binary.Writer, o *fmtLuminance) {
}
func doDecodefmtLuminance(d binary.Reader, o *fmtLuminance) {
}
func doDecodeRawfmtLuminance(d binary.Reader, o *fmtLuminance) {
}
func (*binaryClassfmtLuminance) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtLuminance(e, obj.(*fmtLuminance))
}
func (*binaryClassfmtLuminance) New() binary.Object {
	return &fmtLuminance{}
}
func (*binaryClassfmtLuminance) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtLuminance(d, obj.(*fmtLuminance))
}
func (o *fmtLuminance) WriteSimple(w binary.Writer) {
	doEncodefmtLuminance(w, o)
}
func (o *fmtLuminance) ReadSimple(r binary.Reader) {
	doDecodefmtLuminance(r, o)
}
func (c *binaryClassfmtLuminance) Schema() *binary.Entity {
	return &entities[ixǁfmtLuminance]
}

type binaryClassfmtLuminanceAlpha struct{}

func (*fmtLuminanceAlpha) Class() binary.Class {
	return (*binaryClassfmtLuminanceAlpha)(nil)
}
func doEncodefmtLuminanceAlpha(e binary.Writer, o *fmtLuminanceAlpha) {
}
func doDecodefmtLuminanceAlpha(d binary.Reader, o *fmtLuminanceAlpha) {
}
func doDecodeRawfmtLuminanceAlpha(d binary.Reader, o *fmtLuminanceAlpha) {
}
func (*binaryClassfmtLuminanceAlpha) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtLuminanceAlpha(e, obj.(*fmtLuminanceAlpha))
}
func (*binaryClassfmtLuminanceAlpha) New() binary.Object {
	return &fmtLuminanceAlpha{}
}
func (*binaryClassfmtLuminanceAlpha) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtLuminanceAlpha(d, obj.(*fmtLuminanceAlpha))
}
func (o *fmtLuminanceAlpha) WriteSimple(w binary.Writer) {
	doEncodefmtLuminanceAlpha(w, o)
}
func (o *fmtLuminanceAlpha) ReadSimple(r binary.Reader) {
	doDecodefmtLuminanceAlpha(r, o)
}
func (c *binaryClassfmtLuminanceAlpha) Schema() *binary.Entity {
	return &entities[ixǁfmtLuminanceAlpha]
}

type binaryClassfmtPNG struct{}

func (*fmtPNG) Class() binary.Class {
	return (*binaryClassfmtPNG)(nil)
}
func doEncodefmtPNG(e binary.Writer, o *fmtPNG) {
}
func doDecodefmtPNG(d binary.Reader, o *fmtPNG) {
}
func doDecodeRawfmtPNG(d binary.Reader, o *fmtPNG) {
}
func (*binaryClassfmtPNG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtPNG(e, obj.(*fmtPNG))
}
func (*binaryClassfmtPNG) New() binary.Object {
	return &fmtPNG{}
}
func (*binaryClassfmtPNG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtPNG(d, obj.(*fmtPNG))
}
func (o *fmtPNG) WriteSimple(w binary.Writer) {
	doEncodefmtPNG(w, o)
}
func (o *fmtPNG) ReadSimple(r binary.Reader) {
	doDecodefmtPNG(r, o)
}
func (c *binaryClassfmtPNG) Schema() *binary.Entity {
	return &entities[ixǁfmtPNG]
}

type binaryClassfmtRG struct{}

func (*fmtRG) Class() binary.Class {
	return (*binaryClassfmtRG)(nil)
}
func doEncodefmtRG(e binary.Writer, o *fmtRG) {
}
func doDecodefmtRG(d binary.Reader, o *fmtRG) {
}
func doDecodeRawfmtRG(d binary.Reader, o *fmtRG) {
}
func (*binaryClassfmtRG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRG(e, obj.(*fmtRG))
}
func (*binaryClassfmtRG) New() binary.Object {
	return &fmtRG{}
}
func (*binaryClassfmtRG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRG(d, obj.(*fmtRG))
}
func (o *fmtRG) WriteSimple(w binary.Writer) {
	doEncodefmtRG(w, o)
}
func (o *fmtRG) ReadSimple(r binary.Reader) {
	doDecodefmtRG(r, o)
}
func (c *binaryClassfmtRG) Schema() *binary.Entity {
	return &entities[ixǁfmtRG]
}

type binaryClassfmtRGB struct{}

func (*fmtRGB) Class() binary.Class {
	return (*binaryClassfmtRGB)(nil)
}
func doEncodefmtRGB(e binary.Writer, o *fmtRGB) {
}
func doDecodefmtRGB(d binary.Reader, o *fmtRGB) {
}
func doDecodeRawfmtRGB(d binary.Reader, o *fmtRGB) {
}
func (*binaryClassfmtRGB) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGB(e, obj.(*fmtRGB))
}
func (*binaryClassfmtRGB) New() binary.Object {
	return &fmtRGB{}
}
func (*binaryClassfmtRGB) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGB(d, obj.(*fmtRGB))
}
func (o *fmtRGB) WriteSimple(w binary.Writer) {
	doEncodefmtRGB(w, o)
}
func (o *fmtRGB) ReadSimple(r binary.Reader) {
	doDecodefmtRGB(r, o)
}
func (c *binaryClassfmtRGB) Schema() *binary.Entity {
	return &entities[ixǁfmtRGB]
}

type binaryClassfmtRGB565 struct{}

func (*fmtRGB565) Class() binary.Class {
	return (*binaryClassfmtRGB565)(nil)
}
func doEncodefmtRGB565(e binary.Writer, o *fmtRGB565) {
}
func doDecodefmtRGB565(d binary.Reader, o *fmtRGB565) {
}
func doDecodeRawfmtRGB565(d binary.Reader, o *fmtRGB565) {
}
func (*binaryClassfmtRGB565) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGB565(e, obj.(*fmtRGB565))
}
func (*binaryClassfmtRGB565) New() binary.Object {
	return &fmtRGB565{}
}
func (*binaryClassfmtRGB565) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGB565(d, obj.(*fmtRGB565))
}
func (o *fmtRGB565) WriteSimple(w binary.Writer) {
	doEncodefmtRGB565(w, o)
}
func (o *fmtRGB565) ReadSimple(r binary.Reader) {
	doDecodefmtRGB565(r, o)
}
func (c *binaryClassfmtRGB565) Schema() *binary.Entity {
	return &entities[ixǁfmtRGB565]
}

type binaryClassfmtRGBA struct{}

func (*fmtRGBA) Class() binary.Class {
	return (*binaryClassfmtRGBA)(nil)
}
func doEncodefmtRGBA(e binary.Writer, o *fmtRGBA) {
}
func doDecodefmtRGBA(d binary.Reader, o *fmtRGBA) {
}
func doDecodeRawfmtRGBA(d binary.Reader, o *fmtRGBA) {
}
func (*binaryClassfmtRGBA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBA(e, obj.(*fmtRGBA))
}
func (*binaryClassfmtRGBA) New() binary.Object {
	return &fmtRGBA{}
}
func (*binaryClassfmtRGBA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBA(d, obj.(*fmtRGBA))
}
func (o *fmtRGBA) WriteSimple(w binary.Writer) {
	doEncodefmtRGBA(w, o)
}
func (o *fmtRGBA) ReadSimple(r binary.Reader) {
	doDecodefmtRGBA(r, o)
}
func (c *binaryClassfmtRGBA) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBA]
}

type binaryClassfmtRGBA1010102 struct{}

func (*fmtRGBA1010102) Class() binary.Class {
	return (*binaryClassfmtRGBA1010102)(nil)
}
func doEncodefmtRGBA1010102(e binary.Writer, o *fmtRGBA1010102) {
}
func doDecodefmtRGBA1010102(d binary.Reader, o *fmtRGBA1010102) {
}
func doDecodeRawfmtRGBA1010102(d binary.Reader, o *fmtRGBA1010102) {
}
func (*binaryClassfmtRGBA1010102) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBA1010102(e, obj.(*fmtRGBA1010102))
}
func (*binaryClassfmtRGBA1010102) New() binary.Object {
	return &fmtRGBA1010102{}
}
func (*binaryClassfmtRGBA1010102) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBA1010102(d, obj.(*fmtRGBA1010102))
}
func (o *fmtRGBA1010102) WriteSimple(w binary.Writer) {
	doEncodefmtRGBA1010102(w, o)
}
func (o *fmtRGBA1010102) ReadSimple(r binary.Reader) {
	doDecodefmtRGBA1010102(r, o)
}
func (c *binaryClassfmtRGBA1010102) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBA1010102]
}

type binaryClassfmtRGBA4444 struct{}

func (*fmtRGBA4444) Class() binary.Class {
	return (*binaryClassfmtRGBA4444)(nil)
}
func doEncodefmtRGBA4444(e binary.Writer, o *fmtRGBA4444) {
}
func doDecodefmtRGBA4444(d binary.Reader, o *fmtRGBA4444) {
}
func doDecodeRawfmtRGBA4444(d binary.Reader, o *fmtRGBA4444) {
}
func (*binaryClassfmtRGBA4444) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBA4444(e, obj.(*fmtRGBA4444))
}
func (*binaryClassfmtRGBA4444) New() binary.Object {
	return &fmtRGBA4444{}
}
func (*binaryClassfmtRGBA4444) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBA4444(d, obj.(*fmtRGBA4444))
}
func (o *fmtRGBA4444) WriteSimple(w binary.Writer) {
	doEncodefmtRGBA4444(w, o)
}
func (o *fmtRGBA4444) ReadSimple(r binary.Reader) {
	doDecodefmtRGBA4444(r, o)
}
func (c *binaryClassfmtRGBA4444) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBA4444]
}

type binaryClassfmtRGBA5551 struct{}

func (*fmtRGBA5551) Class() binary.Class {
	return (*binaryClassfmtRGBA5551)(nil)
}
func doEncodefmtRGBA5551(e binary.Writer, o *fmtRGBA5551) {
}
func doDecodefmtRGBA5551(d binary.Reader, o *fmtRGBA5551) {
}
func doDecodeRawfmtRGBA5551(d binary.Reader, o *fmtRGBA5551) {
}
func (*binaryClassfmtRGBA5551) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBA5551(e, obj.(*fmtRGBA5551))
}
func (*binaryClassfmtRGBA5551) New() binary.Object {
	return &fmtRGBA5551{}
}
func (*binaryClassfmtRGBA5551) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBA5551(d, obj.(*fmtRGBA5551))
}
func (o *fmtRGBA5551) WriteSimple(w binary.Writer) {
	doEncodefmtRGBA5551(w, o)
}
func (o *fmtRGBA5551) ReadSimple(r binary.Reader) {
	doDecodefmtRGBA5551(r, o)
}
func (c *binaryClassfmtRGBA5551) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBA5551]
}

type binaryClassfmtRGBAF16 struct{}

func (*fmtRGBAF16) Class() binary.Class {
	return (*binaryClassfmtRGBAF16)(nil)
}
func doEncodefmtRGBAF16(e binary.Writer, o *fmtRGBAF16) {
}
func doDecodefmtRGBAF16(d binary.Reader, o *fmtRGBAF16) {
}
func doDecodeRawfmtRGBAF16(d binary.Reader, o *fmtRGBAF16) {
}
func (*binaryClassfmtRGBAF16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBAF16(e, obj.(*fmtRGBAF16))
}
func (*binaryClassfmtRGBAF16) New() binary.Object {
	return &fmtRGBAF16{}
}
func (*binaryClassfmtRGBAF16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBAF16(d, obj.(*fmtRGBAF16))
}
func (o *fmtRGBAF16) WriteSimple(w binary.Writer) {
	doEncodefmtRGBAF16(w, o)
}
func (o *fmtRGBAF16) ReadSimple(r binary.Reader) {
	doDecodefmtRGBAF16(r, o)
}
func (c *binaryClassfmtRGBAF16) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBAF16]
}

type binaryClassfmtRGBAF32 struct{}

func (*fmtRGBAF32) Class() binary.Class {
	return (*binaryClassfmtRGBAF32)(nil)
}
func doEncodefmtRGBAF32(e binary.Writer, o *fmtRGBAF32) {
}
func doDecodefmtRGBAF32(d binary.Reader, o *fmtRGBAF32) {
}
func doDecodeRawfmtRGBAF32(d binary.Reader, o *fmtRGBAF32) {
}
func (*binaryClassfmtRGBAF32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBAF32(e, obj.(*fmtRGBAF32))
}
func (*binaryClassfmtRGBAF32) New() binary.Object {
	return &fmtRGBAF32{}
}
func (*binaryClassfmtRGBAF32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBAF32(d, obj.(*fmtRGBAF32))
}
func (o *fmtRGBAF32) WriteSimple(w binary.Writer) {
	doEncodefmtRGBAF32(w, o)
}
func (o *fmtRGBAF32) ReadSimple(r binary.Reader) {
	doDecodefmtRGBAF32(r, o)
}
func (c *binaryClassfmtRGBAF32) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBAF32]
}

type binaryClassfmtRGBF16 struct{}

func (*fmtRGBF16) Class() binary.Class {
	return (*binaryClassfmtRGBF16)(nil)
}
func doEncodefmtRGBF16(e binary.Writer, o *fmtRGBF16) {
}
func doDecodefmtRGBF16(d binary.Reader, o *fmtRGBF16) {
}
func doDecodeRawfmtRGBF16(d binary.Reader, o *fmtRGBF16) {
}
func (*binaryClassfmtRGBF16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBF16(e, obj.(*fmtRGBF16))
}
func (*binaryClassfmtRGBF16) New() binary.Object {
	return &fmtRGBF16{}
}
func (*binaryClassfmtRGBF16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBF16(d, obj.(*fmtRGBF16))
}
func (o *fmtRGBF16) WriteSimple(w binary.Writer) {
	doEncodefmtRGBF16(w, o)
}
func (o *fmtRGBF16) ReadSimple(r binary.Reader) {
	doDecodefmtRGBF16(r, o)
}
func (c *binaryClassfmtRGBF16) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBF16]
}

type binaryClassfmtRGBF32 struct{}

func (*fmtRGBF32) Class() binary.Class {
	return (*binaryClassfmtRGBF32)(nil)
}
func doEncodefmtRGBF32(e binary.Writer, o *fmtRGBF32) {
}
func doDecodefmtRGBF32(d binary.Reader, o *fmtRGBF32) {
}
func doDecodeRawfmtRGBF32(d binary.Reader, o *fmtRGBF32) {
}
func (*binaryClassfmtRGBF32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGBF32(e, obj.(*fmtRGBF32))
}
func (*binaryClassfmtRGBF32) New() binary.Object {
	return &fmtRGBF32{}
}
func (*binaryClassfmtRGBF32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGBF32(d, obj.(*fmtRGBF32))
}
func (o *fmtRGBF32) WriteSimple(w binary.Writer) {
	doEncodefmtRGBF32(w, o)
}
func (o *fmtRGBF32) ReadSimple(r binary.Reader) {
	doDecodefmtRGBF32(r, o)
}
func (c *binaryClassfmtRGBF32) Schema() *binary.Entity {
	return &entities[ixǁfmtRGBF32]
}

type binaryClassfmtRGF16 struct{}

func (*fmtRGF16) Class() binary.Class {
	return (*binaryClassfmtRGF16)(nil)
}
func doEncodefmtRGF16(e binary.Writer, o *fmtRGF16) {
}
func doDecodefmtRGF16(d binary.Reader, o *fmtRGF16) {
}
func doDecodeRawfmtRGF16(d binary.Reader, o *fmtRGF16) {
}
func (*binaryClassfmtRGF16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGF16(e, obj.(*fmtRGF16))
}
func (*binaryClassfmtRGF16) New() binary.Object {
	return &fmtRGF16{}
}
func (*binaryClassfmtRGF16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGF16(d, obj.(*fmtRGF16))
}
func (o *fmtRGF16) WriteSimple(w binary.Writer) {
	doEncodefmtRGF16(w, o)
}
func (o *fmtRGF16) ReadSimple(r binary.Reader) {
	doDecodefmtRGF16(r, o)
}
func (c *binaryClassfmtRGF16) Schema() *binary.Entity {
	return &entities[ixǁfmtRGF16]
}

type binaryClassfmtRGF32 struct{}

func (*fmtRGF32) Class() binary.Class {
	return (*binaryClassfmtRGF32)(nil)
}
func doEncodefmtRGF32(e binary.Writer, o *fmtRGF32) {
}
func doDecodefmtRGF32(d binary.Reader, o *fmtRGF32) {
}
func doDecodeRawfmtRGF32(d binary.Reader, o *fmtRGF32) {
}
func (*binaryClassfmtRGF32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRGF32(e, obj.(*fmtRGF32))
}
func (*binaryClassfmtRGF32) New() binary.Object {
	return &fmtRGF32{}
}
func (*binaryClassfmtRGF32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRGF32(d, obj.(*fmtRGF32))
}
func (o *fmtRGF32) WriteSimple(w binary.Writer) {
	doEncodefmtRGF32(w, o)
}
func (o *fmtRGF32) ReadSimple(r binary.Reader) {
	doDecodefmtRGF32(r, o)
}
func (c *binaryClassfmtRGF32) Schema() *binary.Entity {
	return &entities[ixǁfmtRGF32]
}

type binaryClassfmtRed struct{}

func (*fmtRed) Class() binary.Class {
	return (*binaryClassfmtRed)(nil)
}
func doEncodefmtRed(e binary.Writer, o *fmtRed) {
}
func doDecodefmtRed(d binary.Reader, o *fmtRed) {
}
func doDecodeRawfmtRed(d binary.Reader, o *fmtRed) {
}
func (*binaryClassfmtRed) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRed(e, obj.(*fmtRed))
}
func (*binaryClassfmtRed) New() binary.Object {
	return &fmtRed{}
}
func (*binaryClassfmtRed) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRed(d, obj.(*fmtRed))
}
func (o *fmtRed) WriteSimple(w binary.Writer) {
	doEncodefmtRed(w, o)
}
func (o *fmtRed) ReadSimple(r binary.Reader) {
	doDecodefmtRed(r, o)
}
func (c *binaryClassfmtRed) Schema() *binary.Entity {
	return &entities[ixǁfmtRed]
}

type binaryClassfmtRedF16 struct{}

func (*fmtRedF16) Class() binary.Class {
	return (*binaryClassfmtRedF16)(nil)
}
func doEncodefmtRedF16(e binary.Writer, o *fmtRedF16) {
}
func doDecodefmtRedF16(d binary.Reader, o *fmtRedF16) {
}
func doDecodeRawfmtRedF16(d binary.Reader, o *fmtRedF16) {
}
func (*binaryClassfmtRedF16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRedF16(e, obj.(*fmtRedF16))
}
func (*binaryClassfmtRedF16) New() binary.Object {
	return &fmtRedF16{}
}
func (*binaryClassfmtRedF16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRedF16(d, obj.(*fmtRedF16))
}
func (o *fmtRedF16) WriteSimple(w binary.Writer) {
	doEncodefmtRedF16(w, o)
}
func (o *fmtRedF16) ReadSimple(r binary.Reader) {
	doDecodefmtRedF16(r, o)
}
func (c *binaryClassfmtRedF16) Schema() *binary.Entity {
	return &entities[ixǁfmtRedF16]
}

type binaryClassfmtRedF32 struct{}

func (*fmtRedF32) Class() binary.Class {
	return (*binaryClassfmtRedF32)(nil)
}
func doEncodefmtRedF32(e binary.Writer, o *fmtRedF32) {
}
func doDecodefmtRedF32(d binary.Reader, o *fmtRedF32) {
}
func doDecodeRawfmtRedF32(d binary.Reader, o *fmtRedF32) {
}
func (*binaryClassfmtRedF32) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRedF32(e, obj.(*fmtRedF32))
}
func (*binaryClassfmtRedF32) New() binary.Object {
	return &fmtRedF32{}
}
func (*binaryClassfmtRedF32) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRedF32(d, obj.(*fmtRedF32))
}
func (o *fmtRedF32) WriteSimple(w binary.Writer) {
	doEncodefmtRedF32(w, o)
}
func (o *fmtRedF32) ReadSimple(r binary.Reader) {
	doDecodefmtRedF32(r, o)
}
func (c *binaryClassfmtRedF32) Schema() *binary.Entity {
	return &entities[ixǁfmtRedF32]
}

type binaryClassfmtRedU16 struct{}

func (*fmtRedU16) Class() binary.Class {
	return (*binaryClassfmtRedU16)(nil)
}
func doEncodefmtRedU16(e binary.Writer, o *fmtRedU16) {
}
func doDecodefmtRedU16(d binary.Reader, o *fmtRedU16) {
}
func doDecodeRawfmtRedU16(d binary.Reader, o *fmtRedU16) {
}
func (*binaryClassfmtRedU16) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtRedU16(e, obj.(*fmtRedU16))
}
func (*binaryClassfmtRedU16) New() binary.Object {
	return &fmtRedU16{}
}
func (*binaryClassfmtRedU16) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtRedU16(d, obj.(*fmtRedU16))
}
func (o *fmtRedU16) WriteSimple(w binary.Writer) {
	doEncodefmtRedU16(w, o)
}
func (o *fmtRedU16) ReadSimple(r binary.Reader) {
	doDecodefmtRedU16(r, o)
}
func (c *binaryClassfmtRedU16) Schema() *binary.Entity {
	return &entities[ixǁfmtRedU16]
}

type binaryClassfmtS3_DXT1_RGB struct{}

func (*fmtS3_DXT1_RGB) Class() binary.Class {
	return (*binaryClassfmtS3_DXT1_RGB)(nil)
}
func doEncodefmtS3_DXT1_RGB(e binary.Writer, o *fmtS3_DXT1_RGB) {
}
func doDecodefmtS3_DXT1_RGB(d binary.Reader, o *fmtS3_DXT1_RGB) {
}
func doDecodeRawfmtS3_DXT1_RGB(d binary.Reader, o *fmtS3_DXT1_RGB) {
}
func (*binaryClassfmtS3_DXT1_RGB) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtS3_DXT1_RGB(e, obj.(*fmtS3_DXT1_RGB))
}
func (*binaryClassfmtS3_DXT1_RGB) New() binary.Object {
	return &fmtS3_DXT1_RGB{}
}
func (*binaryClassfmtS3_DXT1_RGB) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtS3_DXT1_RGB(d, obj.(*fmtS3_DXT1_RGB))
}
func (o *fmtS3_DXT1_RGB) WriteSimple(w binary.Writer) {
	doEncodefmtS3_DXT1_RGB(w, o)
}
func (o *fmtS3_DXT1_RGB) ReadSimple(r binary.Reader) {
	doDecodefmtS3_DXT1_RGB(r, o)
}
func (c *binaryClassfmtS3_DXT1_RGB) Schema() *binary.Entity {
	return &entities[ixǁfmtS3_DXT1_RGB]
}

type binaryClassfmtS3_DXT1_RGBA struct{}

func (*fmtS3_DXT1_RGBA) Class() binary.Class {
	return (*binaryClassfmtS3_DXT1_RGBA)(nil)
}
func doEncodefmtS3_DXT1_RGBA(e binary.Writer, o *fmtS3_DXT1_RGBA) {
}
func doDecodefmtS3_DXT1_RGBA(d binary.Reader, o *fmtS3_DXT1_RGBA) {
}
func doDecodeRawfmtS3_DXT1_RGBA(d binary.Reader, o *fmtS3_DXT1_RGBA) {
}
func (*binaryClassfmtS3_DXT1_RGBA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtS3_DXT1_RGBA(e, obj.(*fmtS3_DXT1_RGBA))
}
func (*binaryClassfmtS3_DXT1_RGBA) New() binary.Object {
	return &fmtS3_DXT1_RGBA{}
}
func (*binaryClassfmtS3_DXT1_RGBA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtS3_DXT1_RGBA(d, obj.(*fmtS3_DXT1_RGBA))
}
func (o *fmtS3_DXT1_RGBA) WriteSimple(w binary.Writer) {
	doEncodefmtS3_DXT1_RGBA(w, o)
}
func (o *fmtS3_DXT1_RGBA) ReadSimple(r binary.Reader) {
	doDecodefmtS3_DXT1_RGBA(r, o)
}
func (c *binaryClassfmtS3_DXT1_RGBA) Schema() *binary.Entity {
	return &entities[ixǁfmtS3_DXT1_RGBA]
}

type binaryClassfmtS3_DXT3_RGBA struct{}

func (*fmtS3_DXT3_RGBA) Class() binary.Class {
	return (*binaryClassfmtS3_DXT3_RGBA)(nil)
}
func doEncodefmtS3_DXT3_RGBA(e binary.Writer, o *fmtS3_DXT3_RGBA) {
}
func doDecodefmtS3_DXT3_RGBA(d binary.Reader, o *fmtS3_DXT3_RGBA) {
}
func doDecodeRawfmtS3_DXT3_RGBA(d binary.Reader, o *fmtS3_DXT3_RGBA) {
}
func (*binaryClassfmtS3_DXT3_RGBA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtS3_DXT3_RGBA(e, obj.(*fmtS3_DXT3_RGBA))
}
func (*binaryClassfmtS3_DXT3_RGBA) New() binary.Object {
	return &fmtS3_DXT3_RGBA{}
}
func (*binaryClassfmtS3_DXT3_RGBA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtS3_DXT3_RGBA(d, obj.(*fmtS3_DXT3_RGBA))
}
func (o *fmtS3_DXT3_RGBA) WriteSimple(w binary.Writer) {
	doEncodefmtS3_DXT3_RGBA(w, o)
}
func (o *fmtS3_DXT3_RGBA) ReadSimple(r binary.Reader) {
	doDecodefmtS3_DXT3_RGBA(r, o)
}
func (c *binaryClassfmtS3_DXT3_RGBA) Schema() *binary.Entity {
	return &entities[ixǁfmtS3_DXT3_RGBA]
}

type binaryClassfmtS3_DXT5_RGBA struct{}

func (*fmtS3_DXT5_RGBA) Class() binary.Class {
	return (*binaryClassfmtS3_DXT5_RGBA)(nil)
}
func doEncodefmtS3_DXT5_RGBA(e binary.Writer, o *fmtS3_DXT5_RGBA) {
}
func doDecodefmtS3_DXT5_RGBA(d binary.Reader, o *fmtS3_DXT5_RGBA) {
}
func doDecodeRawfmtS3_DXT5_RGBA(d binary.Reader, o *fmtS3_DXT5_RGBA) {
}
func (*binaryClassfmtS3_DXT5_RGBA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodefmtS3_DXT5_RGBA(e, obj.(*fmtS3_DXT5_RGBA))
}
func (*binaryClassfmtS3_DXT5_RGBA) New() binary.Object {
	return &fmtS3_DXT5_RGBA{}
}
func (*binaryClassfmtS3_DXT5_RGBA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodefmtS3_DXT5_RGBA(d, obj.(*fmtS3_DXT5_RGBA))
}
func (o *fmtS3_DXT5_RGBA) WriteSimple(w binary.Writer) {
	doEncodefmtS3_DXT5_RGBA(w, o)
}
func (o *fmtS3_DXT5_RGBA) ReadSimple(r binary.Reader) {
	doDecodefmtS3_DXT5_RGBA(r, o)
}
func (c *binaryClassfmtS3_DXT5_RGBA) Schema() *binary.Entity {
	return &entities[ixǁfmtS3_DXT5_RGBA]
}