// <auto-generated>
//  automatically generated by the FlatBuffers compiler, do not modify
// </auto-generated>

namespace FlatBuffers.Gfbmdl
{

    using global::System;
    using global::FlatBuffers;

    public enum BoneType : uint
    {
        NoSkinning = 0,
        HasSkinning = 1,
    };

    public enum WrapMode : uint
    {
        Repeat = 0,
        Clamp = 1,
        Mirror = 2,
    };

    public enum VertexType : uint
    {
        Position = 0,
        Normal = 1,
        Binormal = 2,
        UV1 = 3,
        UV2 = 4,
        UV3 = 5,
        UV4 = 6,
        Color1 = 7,
        Color2 = 8,
        Color3 = 9,
        Color4 = 10,
        BoneID = 11,
        BoneWeight = 12,
    };

    public enum BufferFormat : uint
    {
        Float = 0,
        HalfFloat = 1,
        Byte = 3,
        Short = 5,
        BytesAsFloat = 8,
    };

    public struct Model : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static Model GetRootAsModel(ByteBuffer _bb) { return GetRootAsModel(_bb, new Model()); }
        public static Model GetRootAsModel(ByteBuffer _bb, Model obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Model __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint Version { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public BoundingBox? Bounding { get { int o = __p.__offset(6); return o != 0 ? (BoundingBox?)(new BoundingBox()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public string TextureNames(int j) { int o = __p.__offset(8); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
        public int TextureNamesLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
        public string ShaderNames(int j) { int o = __p.__offset(10); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
        public int ShaderNamesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
        public UnknownEmpty? Unknown(int j) { int o = __p.__offset(12); return o != 0 ? (UnknownEmpty?)(new UnknownEmpty()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int UnknownLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
        public string MaterialNames(int j) { int o = __p.__offset(14); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
        public int MaterialNamesLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
        public Material? Materials(int j) { int o = __p.__offset(16); return o != 0 ? (Material?)(new Material()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int MaterialsLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
        public Group? Groups(int j) { int o = __p.__offset(18); return o != 0 ? (Group?)(new Group()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int GroupsLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
        public Mesh? Meshes(int j) { int o = __p.__offset(20); return o != 0 ? (Mesh?)(new Mesh()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int MeshesLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
        public Bone? Bones(int j) { int o = __p.__offset(22); return o != 0 ? (Bone?)(new Bone()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int BonesLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
        public CollisionGroup? CollisionGroups(int j) { int o = __p.__offset(24); return o != 0 ? (CollisionGroup?)(new CollisionGroup()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int CollisionGroupsLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }

        public static void StartModel(FlatBufferBuilder builder) { builder.StartObject(11); }
        public static void AddVersion(FlatBufferBuilder builder, uint Version) { builder.AddUint(0, Version, 0); }
        public static void AddBounding(FlatBufferBuilder builder, Offset<BoundingBox> BoundingOffset) { builder.AddStruct(1, BoundingOffset.Value, 0); }
        public static void AddTextureNames(FlatBufferBuilder builder, VectorOffset TextureNamesOffset) { builder.AddOffset(2, TextureNamesOffset.Value, 0); }
        public static VectorOffset CreateTextureNamesVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateTextureNamesVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartTextureNamesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddShaderNames(FlatBufferBuilder builder, VectorOffset ShaderNamesOffset) { builder.AddOffset(3, ShaderNamesOffset.Value, 0); }
        public static VectorOffset CreateShaderNamesVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateShaderNamesVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartShaderNamesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddUnknown(FlatBufferBuilder builder, VectorOffset UnknownOffset) { builder.AddOffset(4, UnknownOffset.Value, 0); }
        public static VectorOffset CreateUnknownVector(FlatBufferBuilder builder, Offset<UnknownEmpty>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateUnknownVectorBlock(FlatBufferBuilder builder, Offset<UnknownEmpty>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartUnknownVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddMaterialNames(FlatBufferBuilder builder, VectorOffset MaterialNamesOffset) { builder.AddOffset(5, MaterialNamesOffset.Value, 0); }
        public static VectorOffset CreateMaterialNamesVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateMaterialNamesVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartMaterialNamesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddMaterials(FlatBufferBuilder builder, VectorOffset MaterialsOffset) { builder.AddOffset(6, MaterialsOffset.Value, 0); }
        public static VectorOffset CreateMaterialsVector(FlatBufferBuilder builder, Offset<Material>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateMaterialsVectorBlock(FlatBufferBuilder builder, Offset<Material>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartMaterialsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddGroups(FlatBufferBuilder builder, VectorOffset GroupsOffset) { builder.AddOffset(7, GroupsOffset.Value, 0); }
        public static VectorOffset CreateGroupsVector(FlatBufferBuilder builder, Offset<Group>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateGroupsVectorBlock(FlatBufferBuilder builder, Offset<Group>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartGroupsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddMeshes(FlatBufferBuilder builder, VectorOffset MeshesOffset) { builder.AddOffset(8, MeshesOffset.Value, 0); }
        public static VectorOffset CreateMeshesVector(FlatBufferBuilder builder, Offset<Mesh>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateMeshesVectorBlock(FlatBufferBuilder builder, Offset<Mesh>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartMeshesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddBones(FlatBufferBuilder builder, VectorOffset BonesOffset) { builder.AddOffset(9, BonesOffset.Value, 0); }
        public static VectorOffset CreateBonesVector(FlatBufferBuilder builder, Offset<Bone>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateBonesVectorBlock(FlatBufferBuilder builder, Offset<Bone>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartBonesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddCollisionGroups(FlatBufferBuilder builder, VectorOffset CollisionGroupsOffset) { builder.AddOffset(10, CollisionGroupsOffset.Value, 0); }
        public static VectorOffset CreateCollisionGroupsVector(FlatBufferBuilder builder, Offset<CollisionGroup>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateCollisionGroupsVectorBlock(FlatBufferBuilder builder, Offset<CollisionGroup>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartCollisionGroupsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static Offset<Model> EndModel(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<Model>(o);
        }
        public static void FinishModelBuffer(FlatBufferBuilder builder, Offset<Model> offset) { builder.Finish(offset.Value); }
        public static void FinishSizePrefixedModelBuffer(FlatBufferBuilder builder, Offset<Model> offset) { builder.FinishSizePrefixed(offset.Value); }
    };

    public struct UnknownEmpty : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static UnknownEmpty GetRootAsUnknownEmpty(ByteBuffer _bb) { return GetRootAsUnknownEmpty(_bb, new UnknownEmpty()); }
        public static UnknownEmpty GetRootAsUnknownEmpty(ByteBuffer _bb, UnknownEmpty obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public UnknownEmpty __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint Unk { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }

        public static Offset<UnknownEmpty> CreateUnknownEmpty(FlatBufferBuilder builder,
            uint unk = 0)
        {
            builder.StartObject(1);
            UnknownEmpty.AddUnk(builder, unk);
            return UnknownEmpty.EndUnknownEmpty(builder);
        }

        public static void StartUnknownEmpty(FlatBufferBuilder builder) { builder.StartObject(1); }
        public static void AddUnk(FlatBufferBuilder builder, uint unk) { builder.AddUint(0, unk, 0); }
        public static Offset<UnknownEmpty> EndUnknownEmpty(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<UnknownEmpty>(o);
        }
    };

    public struct Material : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static Material GetRootAsMaterial(ByteBuffer _bb) { return GetRootAsMaterial(_bb, new Material()); }
        public static Material GetRootAsMaterial(ByteBuffer _bb, Material obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Material __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public string ShaderGroup { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetShaderGroupBytes() { return __p.__vector_as_span(6); }
#else
        public ArraySegment<byte>? GetShaderGroupBytes() { return __p.__vector_as_arraysegment(6); }
#endif
        public byte[] GetShaderGroupArray() { return __p.__vector_as_array<byte>(6); }
        public int RenderLayer { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public byte Unknown1 { get { int o = __p.__offset(10); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public byte Unknown2 { get { int o = __p.__offset(12); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public int Parameter1 { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public int Parameter2 { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public int Parameter3 { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public int ShaderIndex { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public int Parameter4 { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public int Parameter5 { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public TextureMap? TextureMaps(int j) { int o = __p.__offset(26); return o != 0 ? (TextureMap?)(new TextureMap()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int TextureMapsLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MatSwitch? Switches(int j) { int o = __p.__offset(28); return o != 0 ? (MatSwitch?)(new MatSwitch()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int SwitchesLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MatFloat? Values(int j) { int o = __p.__offset(30); return o != 0 ? (MatFloat?)(new MatFloat()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int ValuesLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MatColor? Colors(int j) { int o = __p.__offset(32); return o != 0 ? (MatColor?)(new MatColor()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int ColorsLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
        public byte Unknown3 { get { int o = __p.__offset(34); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public byte Unknown4 { get { int o = __p.__offset(36); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public byte Unknown5 { get { int o = __p.__offset(38); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public byte Unknown6 { get { int o = __p.__offset(40); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public byte Unknown7 { get { int o = __p.__offset(42); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
        public MaterialCommon? Common { get { int o = __p.__offset(44); return o != 0 ? (MaterialCommon?)(new MaterialCommon()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }

        public static Offset<Material> CreateMaterial(FlatBufferBuilder builder,
            StringOffset NameOffset = default(StringOffset),
            StringOffset ShaderGroupOffset = default(StringOffset),
            int RenderLayer = 0,
            byte Unknown1 = 0,
            byte Unknown2 = 0,
            int Parameter1 = 0,
            int Parameter2 = 0,
            int Parameter3 = 0,
            int ShaderIndex = 0,
            int Parameter4 = 0,
            int Parameter5 = 0,
            VectorOffset TextureMapsOffset = default(VectorOffset),
            VectorOffset SwitchesOffset = default(VectorOffset),
            VectorOffset ValuesOffset = default(VectorOffset),
            VectorOffset ColorsOffset = default(VectorOffset),
            byte Unknown3 = 0,
            byte Unknown4 = 0,
            byte Unknown5 = 0,
            byte Unknown6 = 0,
            byte Unknown7 = 0,
            Offset<MaterialCommon> CommonOffset = default(Offset<MaterialCommon>))
        {
            builder.StartObject(21);
            Material.AddCommon(builder, CommonOffset);
            Material.AddColors(builder, ColorsOffset);
            Material.AddValues(builder, ValuesOffset);
            Material.AddSwitches(builder, SwitchesOffset);
            Material.AddTextureMaps(builder, TextureMapsOffset);
            Material.AddParameter5(builder, Parameter5);
            Material.AddParameter4(builder, Parameter4);
            Material.AddShaderIndex(builder, ShaderIndex);
            Material.AddParameter3(builder, Parameter3);
            Material.AddParameter2(builder, Parameter2);
            Material.AddParameter1(builder, Parameter1);
            Material.AddRenderLayer(builder, RenderLayer);
            Material.AddShaderGroup(builder, ShaderGroupOffset);
            Material.AddName(builder, NameOffset);
            Material.AddUnknown7(builder, Unknown7);
            Material.AddUnknown6(builder, Unknown6);
            Material.AddUnknown5(builder, Unknown5);
            Material.AddUnknown4(builder, Unknown4);
            Material.AddUnknown3(builder, Unknown3);
            Material.AddUnknown2(builder, Unknown2);
            Material.AddUnknown1(builder, Unknown1);
            return Material.EndMaterial(builder);
        }

        public static void StartMaterial(FlatBufferBuilder builder) { builder.StartObject(21); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddShaderGroup(FlatBufferBuilder builder, StringOffset ShaderGroupOffset) { builder.AddOffset(1, ShaderGroupOffset.Value, 0); }
        public static void AddRenderLayer(FlatBufferBuilder builder, int RenderLayer) { builder.AddInt(2, RenderLayer, 0); }
        public static void AddUnknown1(FlatBufferBuilder builder, byte Unknown1) { builder.AddByte(3, Unknown1, 0); }
        public static void AddUnknown2(FlatBufferBuilder builder, byte Unknown2) { builder.AddByte(4, Unknown2, 0); }
        public static void AddParameter1(FlatBufferBuilder builder, int Parameter1) { builder.AddInt(5, Parameter1, 0); }
        public static void AddParameter2(FlatBufferBuilder builder, int Parameter2) { builder.AddInt(6, Parameter2, 0); }
        public static void AddParameter3(FlatBufferBuilder builder, int Parameter3) { builder.AddInt(7, Parameter3, 0); }
        public static void AddShaderIndex(FlatBufferBuilder builder, int ShaderIndex) { builder.AddInt(8, ShaderIndex, 0); }
        public static void AddParameter4(FlatBufferBuilder builder, int Parameter4) { builder.AddInt(9, Parameter4, 0); }
        public static void AddParameter5(FlatBufferBuilder builder, int Parameter5) { builder.AddInt(10, Parameter5, 0); }
        public static void AddTextureMaps(FlatBufferBuilder builder, VectorOffset TextureMapsOffset) { builder.AddOffset(11, TextureMapsOffset.Value, 0); }
        public static VectorOffset CreateTextureMapsVector(FlatBufferBuilder builder, Offset<TextureMap>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateTextureMapsVectorBlock(FlatBufferBuilder builder, Offset<TextureMap>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartTextureMapsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddSwitches(FlatBufferBuilder builder, VectorOffset SwitchesOffset) { builder.AddOffset(12, SwitchesOffset.Value, 0); }
        public static VectorOffset CreateSwitchesVector(FlatBufferBuilder builder, Offset<MatSwitch>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateSwitchesVectorBlock(FlatBufferBuilder builder, Offset<MatSwitch>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartSwitchesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(13, ValuesOffset.Value, 0); }
        public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, Offset<MatFloat>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateValuesVectorBlock(FlatBufferBuilder builder, Offset<MatFloat>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddColors(FlatBufferBuilder builder, VectorOffset ColorsOffset) { builder.AddOffset(14, ColorsOffset.Value, 0); }
        public static VectorOffset CreateColorsVector(FlatBufferBuilder builder, Offset<MatColor>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateColorsVectorBlock(FlatBufferBuilder builder, Offset<MatColor>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartColorsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddUnknown3(FlatBufferBuilder builder, byte Unknown3) { builder.AddByte(15, Unknown3, 0); }
        public static void AddUnknown4(FlatBufferBuilder builder, byte Unknown4) { builder.AddByte(16, Unknown4, 0); }
        public static void AddUnknown5(FlatBufferBuilder builder, byte Unknown5) { builder.AddByte(17, Unknown5, 0); }
        public static void AddUnknown6(FlatBufferBuilder builder, byte Unknown6) { builder.AddByte(18, Unknown6, 0); }
        public static void AddUnknown7(FlatBufferBuilder builder, byte Unknown7) { builder.AddByte(19, Unknown7, 0); }
        public static void AddCommon(FlatBufferBuilder builder, Offset<MaterialCommon> CommonOffset) { builder.AddOffset(20, CommonOffset.Value, 0); }
        public static Offset<Material> EndMaterial(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<Material>(o);
        }
    };

    public struct MaterialCommon : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MaterialCommon GetRootAsMaterialCommon(ByteBuffer _bb) { return GetRootAsMaterialCommon(_bb, new MaterialCommon()); }
        public static MaterialCommon GetRootAsMaterialCommon(ByteBuffer _bb, MaterialCommon obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MaterialCommon __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public MatSwitch? Switches(int j) { int o = __p.__offset(4); return o != 0 ? (MatSwitch?)(new MatSwitch()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int SwitchesLength { get { int o = __p.__offset(4); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MatInt? Values(int j) { int o = __p.__offset(6); return o != 0 ? (MatInt?)(new MatInt()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int ValuesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MatColor? Colors(int j) { int o = __p.__offset(8); return o != 0 ? (MatColor?)(new MatColor()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int ColorsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }

        public static Offset<MaterialCommon> CreateMaterialCommon(FlatBufferBuilder builder,
            VectorOffset SwitchesOffset = default(VectorOffset),
            VectorOffset ValuesOffset = default(VectorOffset),
            VectorOffset ColorsOffset = default(VectorOffset))
        {
            builder.StartObject(3);
            MaterialCommon.AddColors(builder, ColorsOffset);
            MaterialCommon.AddValues(builder, ValuesOffset);
            MaterialCommon.AddSwitches(builder, SwitchesOffset);
            return MaterialCommon.EndMaterialCommon(builder);
        }

        public static void StartMaterialCommon(FlatBufferBuilder builder) { builder.StartObject(3); }
        public static void AddSwitches(FlatBufferBuilder builder, VectorOffset SwitchesOffset) { builder.AddOffset(0, SwitchesOffset.Value, 0); }
        public static VectorOffset CreateSwitchesVector(FlatBufferBuilder builder, Offset<MatSwitch>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateSwitchesVectorBlock(FlatBufferBuilder builder, Offset<MatSwitch>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartSwitchesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(1, ValuesOffset.Value, 0); }
        public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, Offset<MatInt>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateValuesVectorBlock(FlatBufferBuilder builder, Offset<MatInt>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddColors(FlatBufferBuilder builder, VectorOffset ColorsOffset) { builder.AddOffset(2, ColorsOffset.Value, 0); }
        public static VectorOffset CreateColorsVector(FlatBufferBuilder builder, Offset<MatColor>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateColorsVectorBlock(FlatBufferBuilder builder, Offset<MatColor>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartColorsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static Offset<MaterialCommon> EndMaterialCommon(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MaterialCommon>(o);
        }
    };

    public struct MatSwitch : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MatSwitch GetRootAsMatSwitch(ByteBuffer _bb) { return GetRootAsMatSwitch(_bb, new MatSwitch()); }
        public static MatSwitch GetRootAsMatSwitch(ByteBuffer _bb, MatSwitch obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MatSwitch __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public bool Value { get { int o = __p.__offset(6); return o != 0 ? 0 != __p.bb.Get(o + __p.bb_pos) : (bool)false; } }

        public static Offset<MatSwitch> CreateMatSwitch(FlatBufferBuilder builder,
            StringOffset NameOffset = default(StringOffset),
            bool Value = false)
        {
            builder.StartObject(2);
            MatSwitch.AddName(builder, NameOffset);
            MatSwitch.AddValue(builder, Value);
            return MatSwitch.EndMatSwitch(builder);
        }

        public static void StartMatSwitch(FlatBufferBuilder builder) { builder.StartObject(2); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddValue(FlatBufferBuilder builder, bool Value) { builder.AddBool(1, Value, false); }
        public static Offset<MatSwitch> EndMatSwitch(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MatSwitch>(o);
        }
    };

    public struct MatColor : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MatColor GetRootAsMatColor(ByteBuffer _bb) { return GetRootAsMatColor(_bb, new MatColor()); }
        public static MatColor GetRootAsMatColor(ByteBuffer _bb, MatColor obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MatColor __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public ColorRGB32? Color { get { int o = __p.__offset(6); return o != 0 ? (ColorRGB32?)(new ColorRGB32()).__assign(o + __p.bb_pos, __p.bb) : null; } }

        public static void StartMatColor(FlatBufferBuilder builder) { builder.StartObject(2); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddColor(FlatBufferBuilder builder, Offset<ColorRGB32> ColorOffset) { builder.AddStruct(1, ColorOffset.Value, 0); }
        public static Offset<MatColor> EndMatColor(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MatColor>(o);
        }
    };

    public struct MatInt : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MatInt GetRootAsMatInt(ByteBuffer _bb) { return GetRootAsMatInt(_bb, new MatInt()); }
        public static MatInt GetRootAsMatInt(ByteBuffer _bb, MatInt obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MatInt __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public int Value { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }

        public static Offset<MatInt> CreateMatInt(FlatBufferBuilder builder,
            StringOffset NameOffset = default(StringOffset),
            int Value = 0)
        {
            builder.StartObject(2);
            MatInt.AddValue(builder, Value);
            MatInt.AddName(builder, NameOffset);
            return MatInt.EndMatInt(builder);
        }

        public static void StartMatInt(FlatBufferBuilder builder) { builder.StartObject(2); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddValue(FlatBufferBuilder builder, int Value) { builder.AddInt(1, Value, 0); }
        public static Offset<MatInt> EndMatInt(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MatInt>(o);
        }
    };

    public struct MatFloat : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MatFloat GetRootAsMatFloat(ByteBuffer _bb) { return GetRootAsMatFloat(_bb, new MatFloat()); }
        public static MatFloat GetRootAsMatFloat(ByteBuffer _bb, MatFloat obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MatFloat __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public float Value { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }

        public static Offset<MatFloat> CreateMatFloat(FlatBufferBuilder builder,
            StringOffset NameOffset = default(StringOffset),
            float Value = 0.0f)
        {
            builder.StartObject(2);
            MatFloat.AddValue(builder, Value);
            MatFloat.AddName(builder, NameOffset);
            return MatFloat.EndMatFloat(builder);
        }

        public static void StartMatFloat(FlatBufferBuilder builder) { builder.StartObject(2); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddValue(FlatBufferBuilder builder, float Value) { builder.AddFloat(1, Value, 0.0f); }
        public static Offset<MatFloat> EndMatFloat(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MatFloat>(o);
        }
    };

    public struct TextureMap : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static TextureMap GetRootAsTextureMap(ByteBuffer _bb) { return GetRootAsTextureMap(_bb, new TextureMap()); }
        public static TextureMap GetRootAsTextureMap(ByteBuffer _bb, TextureMap obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public TextureMap __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Sampler { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetSamplerBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetSamplerBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetSamplerArray() { return __p.__vector_as_array<byte>(4); }
        public int Index { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public TextureMapping? Params { get { int o = __p.__offset(8); return o != 0 ? (TextureMapping?)(new TextureMapping()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }

        public static Offset<TextureMap> CreateTextureMap(FlatBufferBuilder builder,
            StringOffset SamplerOffset = default(StringOffset),
            int Index = 0,
            Offset<TextureMapping> ParamsOffset = default(Offset<TextureMapping>))
        {
            builder.StartObject(3);
            TextureMap.AddParams(builder, ParamsOffset);
            TextureMap.AddIndex(builder, Index);
            TextureMap.AddSampler(builder, SamplerOffset);
            return TextureMap.EndTextureMap(builder);
        }

        public static void StartTextureMap(FlatBufferBuilder builder) { builder.StartObject(3); }
        public static void AddSampler(FlatBufferBuilder builder, StringOffset SamplerOffset) { builder.AddOffset(0, SamplerOffset.Value, 0); }
        public static void AddIndex(FlatBufferBuilder builder, int Index) { builder.AddInt(1, Index, 0); }
        public static void AddParams(FlatBufferBuilder builder, Offset<TextureMapping> ParamsOffset) { builder.AddOffset(2, ParamsOffset.Value, 0); }
        public static Offset<TextureMap> EndTextureMap(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<TextureMap>(o);
        }
    };

    public struct TextureMapping : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static TextureMapping GetRootAsTextureMapping(ByteBuffer _bb) { return GetRootAsTextureMapping(_bb, new TextureMapping()); }
        public static TextureMapping GetRootAsTextureMapping(ByteBuffer _bb, TextureMapping obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public TextureMapping __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint Unknown1 { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public WrapMode WrapModeX { get { int o = __p.__offset(6); return o != 0 ? (WrapMode)__p.bb.GetUint(o + __p.bb_pos) : WrapMode.Repeat; } }
        public WrapMode WrapModeY { get { int o = __p.__offset(8); return o != 0 ? (WrapMode)__p.bb.GetUint(o + __p.bb_pos) : WrapMode.Repeat; } }
        public WrapMode WrapModeZ { get { int o = __p.__offset(10); return o != 0 ? (WrapMode)__p.bb.GetUint(o + __p.bb_pos) : WrapMode.Repeat; } }
        public float Unknown5 { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
        public float Unknown6 { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
        public float Unknown7 { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
        public float Unknown8 { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
        public float LodBias { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }

        public static Offset<TextureMapping> CreateTextureMapping(FlatBufferBuilder builder,
            uint Unknown1 = 0,
            WrapMode WrapModeX = WrapMode.Repeat,
            WrapMode WrapModeY = WrapMode.Repeat,
            WrapMode WrapModeZ = WrapMode.Repeat,
            float Unknown5 = 0.0f,
            float Unknown6 = 0.0f,
            float Unknown7 = 0.0f,
            float Unknown8 = 0.0f,
            float lodBias = 0.0f)
        {
            builder.StartObject(9);
            TextureMapping.AddLodBias(builder, lodBias);
            TextureMapping.AddUnknown8(builder, Unknown8);
            TextureMapping.AddUnknown7(builder, Unknown7);
            TextureMapping.AddUnknown6(builder, Unknown6);
            TextureMapping.AddUnknown5(builder, Unknown5);
            TextureMapping.AddWrapModeZ(builder, WrapModeZ);
            TextureMapping.AddWrapModeY(builder, WrapModeY);
            TextureMapping.AddWrapModeX(builder, WrapModeX);
            TextureMapping.AddUnknown1(builder, Unknown1);
            return TextureMapping.EndTextureMapping(builder);
        }

        public static void StartTextureMapping(FlatBufferBuilder builder) { builder.StartObject(9); }
        public static void AddUnknown1(FlatBufferBuilder builder, uint Unknown1) { builder.AddUint(0, Unknown1, 0); }
        public static void AddWrapModeX(FlatBufferBuilder builder, WrapMode WrapModeX) { builder.AddUint(1, (uint)WrapModeX, 0); }
        public static void AddWrapModeY(FlatBufferBuilder builder, WrapMode WrapModeY) { builder.AddUint(2, (uint)WrapModeY, 0); }
        public static void AddWrapModeZ(FlatBufferBuilder builder, WrapMode WrapModeZ) { builder.AddUint(3, (uint)WrapModeZ, 0); }
        public static void AddUnknown5(FlatBufferBuilder builder, float Unknown5) { builder.AddFloat(4, Unknown5, 0.0f); }
        public static void AddUnknown6(FlatBufferBuilder builder, float Unknown6) { builder.AddFloat(5, Unknown6, 0.0f); }
        public static void AddUnknown7(FlatBufferBuilder builder, float Unknown7) { builder.AddFloat(6, Unknown7, 0.0f); }
        public static void AddUnknown8(FlatBufferBuilder builder, float Unknown8) { builder.AddFloat(7, Unknown8, 0.0f); }
        public static void AddLodBias(FlatBufferBuilder builder, float lodBias) { builder.AddFloat(8, lodBias, 0.0f); }
        public static Offset<TextureMapping> EndTextureMapping(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<TextureMapping>(o);
        }
    };

    public struct Group : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static Group GetRootAsGroup(ByteBuffer _bb) { return GetRootAsGroup(_bb, new Group()); }
        public static Group GetRootAsGroup(ByteBuffer _bb, Group obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Group __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint BoneIndex { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public uint MeshIndex { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public BoundingBox? Bounding { get { int o = __p.__offset(8); return o != 0 ? (BoundingBox?)(new BoundingBox()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public uint Layer { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }

        public static void StartGroup(FlatBufferBuilder builder) { builder.StartObject(4); }
        public static void AddBoneIndex(FlatBufferBuilder builder, uint BoneIndex) { builder.AddUint(0, BoneIndex, 0); }
        public static void AddMeshIndex(FlatBufferBuilder builder, uint MeshIndex) { builder.AddUint(1, MeshIndex, 0); }
        public static void AddBounding(FlatBufferBuilder builder, Offset<BoundingBox> BoundingOffset) { builder.AddStruct(2, BoundingOffset.Value, 0); }
        public static void AddLayer(FlatBufferBuilder builder, uint Layer) { builder.AddUint(3, Layer, 0); }
        public static Offset<Group> EndGroup(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<Group>(o);
        }
    };

    public struct Mesh : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static Mesh GetRootAsMesh(ByteBuffer _bb) { return GetRootAsMesh(_bb, new Mesh()); }
        public static Mesh GetRootAsMesh(ByteBuffer _bb, Mesh obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Mesh __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public MeshPolygon? Polygons(int j) { int o = __p.__offset(4); return o != 0 ? (MeshPolygon?)(new MeshPolygon()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int PolygonsLength { get { int o = __p.__offset(4); return o != 0 ? __p.__vector_len(o) : 0; } }
        public MeshAttribute? Attributes(int j) { int o = __p.__offset(6); return o != 0 ? (MeshAttribute?)(new MeshAttribute()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
        public int AttributesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
        public byte Data(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
        public int DataLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
  public Span<byte> GetDataBytes() { return __p.__vector_as_span(8); }
#else
        public ArraySegment<byte>? GetDataBytes() { return __p.__vector_as_arraysegment(8); }
#endif
        public byte[] GetDataArray() { return __p.__vector_as_array<byte>(8); }

        public static Offset<Mesh> CreateMesh(FlatBufferBuilder builder,
            VectorOffset PolygonsOffset = default(VectorOffset),
            VectorOffset AttributesOffset = default(VectorOffset),
            VectorOffset DataOffset = default(VectorOffset))
        {
            builder.StartObject(3);
            Mesh.AddData(builder, DataOffset);
            Mesh.AddAttributes(builder, AttributesOffset);
            Mesh.AddPolygons(builder, PolygonsOffset);
            return Mesh.EndMesh(builder);
        }

        public static void StartMesh(FlatBufferBuilder builder) { builder.StartObject(3); }
        public static void AddPolygons(FlatBufferBuilder builder, VectorOffset PolygonsOffset) { builder.AddOffset(0, PolygonsOffset.Value, 0); }
        public static VectorOffset CreatePolygonsVector(FlatBufferBuilder builder, Offset<MeshPolygon>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreatePolygonsVectorBlock(FlatBufferBuilder builder, Offset<MeshPolygon>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartPolygonsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddAttributes(FlatBufferBuilder builder, VectorOffset AttributesOffset) { builder.AddOffset(1, AttributesOffset.Value, 0); }
        public static VectorOffset CreateAttributesVector(FlatBufferBuilder builder, Offset<MeshAttribute>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
        public static VectorOffset CreateAttributesVectorBlock(FlatBufferBuilder builder, Offset<MeshAttribute>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartAttributesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddData(FlatBufferBuilder builder, VectorOffset DataOffset) { builder.AddOffset(2, DataOffset.Value, 0); }
        public static VectorOffset CreateDataVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
        public static VectorOffset CreateDataVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
        public static void StartDataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
        public static Offset<Mesh> EndMesh(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<Mesh>(o);
        }
    };

    public struct MeshPolygon : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MeshPolygon GetRootAsMeshPolygon(ByteBuffer _bb) { return GetRootAsMeshPolygon(_bb, new MeshPolygon()); }
        public static MeshPolygon GetRootAsMeshPolygon(ByteBuffer _bb, MeshPolygon obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MeshPolygon __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint MaterialIndex { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public ushort Faces(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUshort(__p.__vector(o) + j * 2) : (ushort)0; }
        public int FacesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
  public Span<byte> GetFacesBytes() { return __p.__vector_as_span(6); }
#else
        public ArraySegment<byte>? GetFacesBytes() { return __p.__vector_as_arraysegment(6); }
#endif
        public ushort[] GetFacesArray() { return __p.__vector_as_array<ushort>(6); }

        public static Offset<MeshPolygon> CreateMeshPolygon(FlatBufferBuilder builder,
            uint MaterialIndex = 0,
            VectorOffset FacesOffset = default(VectorOffset))
        {
            builder.StartObject(2);
            MeshPolygon.AddFaces(builder, FacesOffset);
            MeshPolygon.AddMaterialIndex(builder, MaterialIndex);
            return MeshPolygon.EndMeshPolygon(builder);
        }

        public static void StartMeshPolygon(FlatBufferBuilder builder) { builder.StartObject(2); }
        public static void AddMaterialIndex(FlatBufferBuilder builder, uint MaterialIndex) { builder.AddUint(0, MaterialIndex, 0); }
        public static void AddFaces(FlatBufferBuilder builder, VectorOffset FacesOffset) { builder.AddOffset(1, FacesOffset.Value, 0); }
        public static VectorOffset CreateFacesVector(FlatBufferBuilder builder, ushort[] data) { builder.StartVector(2, data.Length, 2); for (int i = data.Length - 1; i >= 0; i--) builder.AddUshort(data[i]); return builder.EndVector(); }
        public static VectorOffset CreateFacesVectorBlock(FlatBufferBuilder builder, ushort[] data) { builder.StartVector(2, data.Length, 2); builder.Add(data); return builder.EndVector(); }
        public static void StartFacesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(2, numElems, 2); }
        public static Offset<MeshPolygon> EndMeshPolygon(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MeshPolygon>(o);
        }
    };

    public struct MeshAttribute : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static MeshAttribute GetRootAsMeshAttribute(ByteBuffer _bb) { return GetRootAsMeshAttribute(_bb, new MeshAttribute()); }
        public static MeshAttribute GetRootAsMeshAttribute(ByteBuffer _bb, MeshAttribute obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public MeshAttribute __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint VertexType { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public uint BufferFormat { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public uint ElementCount { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }

        public static Offset<MeshAttribute> CreateMeshAttribute(FlatBufferBuilder builder,
            uint VertexType = 0,
            uint BufferFormat = 0,
            uint ElementCount = 0)
        {
            builder.StartObject(3);
            MeshAttribute.AddElementCount(builder, ElementCount);
            MeshAttribute.AddBufferFormat(builder, BufferFormat);
            MeshAttribute.AddVertexType(builder, VertexType);
            return MeshAttribute.EndMeshAttribute(builder);
        }

        public static void StartMeshAttribute(FlatBufferBuilder builder) { builder.StartObject(3); }
        public static void AddVertexType(FlatBufferBuilder builder, uint VertexType) { builder.AddUint(0, VertexType, 0); }
        public static void AddBufferFormat(FlatBufferBuilder builder, uint BufferFormat) { builder.AddUint(1, BufferFormat, 0); }
        public static void AddElementCount(FlatBufferBuilder builder, uint ElementCount) { builder.AddUint(2, ElementCount, 0); }
        public static Offset<MeshAttribute> EndMeshAttribute(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<MeshAttribute>(o);
        }
    };

    public struct Bone : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static Bone GetRootAsBone(ByteBuffer _bb) { return GetRootAsBone(_bb, new Bone()); }
        public static Bone GetRootAsBone(ByteBuffer _bb, Bone obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Bone __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
#else
        public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
#endif
        public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
        public uint BoneType { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public int Parent { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
        public uint Zero { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public bool Visible { get { int o = __p.__offset(12); return o != 0 ? 0 != __p.bb.Get(o + __p.bb_pos) : (bool)false; } }
        public Vector3? Scale { get { int o = __p.__offset(14); return o != 0 ? (Vector3?)(new Vector3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public Vector3? Rotation { get { int o = __p.__offset(16); return o != 0 ? (Vector3?)(new Vector3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public Vector3? Translation { get { int o = __p.__offset(18); return o != 0 ? (Vector3?)(new Vector3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public Vector3? RadiusStart { get { int o = __p.__offset(20); return o != 0 ? (Vector3?)(new Vector3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public Vector3? RadiusEnd { get { int o = __p.__offset(22); return o != 0 ? (Vector3?)(new Vector3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
        public BoneRigidData? RigidCheck { get { int o = __p.__offset(24); return o != 0 ? (BoneRigidData?)(new BoneRigidData()).__assign(o + __p.bb_pos, __p.bb) : null; } }

        public static void StartBone(FlatBufferBuilder builder) { builder.StartObject(11); }
        public static void AddName(FlatBufferBuilder builder, StringOffset NameOffset) { builder.AddOffset(0, NameOffset.Value, 0); }
        public static void AddBoneType(FlatBufferBuilder builder, uint BoneType) { builder.AddUint(1, BoneType, 0); }
        public static void AddParent(FlatBufferBuilder builder, int Parent) { builder.AddInt(2, Parent, 0); }
        public static void AddZero(FlatBufferBuilder builder, uint Zero) { builder.AddUint(3, Zero, 0); }
        public static void AddVisible(FlatBufferBuilder builder, bool Visible) { builder.AddBool(4, Visible, false); }
        public static void AddScale(FlatBufferBuilder builder, Offset<Vector3> ScaleOffset) { builder.AddStruct(5, ScaleOffset.Value, 0); }
        public static void AddRotation(FlatBufferBuilder builder, Offset<Vector3> RotationOffset) { builder.AddStruct(6, RotationOffset.Value, 0); }
        public static void AddTranslation(FlatBufferBuilder builder, Offset<Vector3> TranslationOffset) { builder.AddStruct(7, TranslationOffset.Value, 0); }
        public static void AddRadiusStart(FlatBufferBuilder builder, Offset<Vector3> RadiusStartOffset) { builder.AddStruct(8, RadiusStartOffset.Value, 0); }
        public static void AddRadiusEnd(FlatBufferBuilder builder, Offset<Vector3> RadiusEndOffset) { builder.AddStruct(9, RadiusEndOffset.Value, 0); }
        public static void AddRigidCheck(FlatBufferBuilder builder, Offset<BoneRigidData> RigidCheckOffset) { builder.AddStruct(10, RigidCheckOffset.Value, 0); }
        public static Offset<Bone> EndBone(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<Bone>(o);
        }
    };

    public struct BoneRigidData : IFlatbufferObject
    {
        private Struct __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public BoneRigidData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public sbyte Unknown1 { get { return __p.bb.GetSbyte(__p.bb_pos + 0); } }

        public static Offset<BoneRigidData> CreateBoneRigidData(FlatBufferBuilder builder, sbyte Unknown1)
        {
            builder.Prep(1, 1);
            builder.PutSbyte(Unknown1);
            return new Offset<BoneRigidData>(builder.Offset);
        }
    };

    public struct CollisionGroup : IFlatbufferObject
    {
        private Table __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public static CollisionGroup GetRootAsCollisionGroup(ByteBuffer _bb) { return GetRootAsCollisionGroup(_bb, new CollisionGroup()); }
        public static CollisionGroup GetRootAsCollisionGroup(ByteBuffer _bb, CollisionGroup obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public CollisionGroup __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public uint BoneIndex { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public uint Unknown1 { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
        public uint BoneChildren(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
        public int BoneChildrenLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
  public Span<byte> GetBoneChildrenBytes() { return __p.__vector_as_span(8); }
#else
        public ArraySegment<byte>? GetBoneChildrenBytes() { return __p.__vector_as_arraysegment(8); }
#endif
        public uint[] GetBoneChildrenArray() { return __p.__vector_as_array<uint>(8); }
        public BoundingBox? Bounding { get { int o = __p.__offset(10); return o != 0 ? (BoundingBox?)(new BoundingBox()).__assign(o + __p.bb_pos, __p.bb) : null; } }

        public static void StartCollisionGroup(FlatBufferBuilder builder) { builder.StartObject(4); }
        public static void AddBoneIndex(FlatBufferBuilder builder, uint BoneIndex) { builder.AddUint(0, BoneIndex, 0); }
        public static void AddUnknown1(FlatBufferBuilder builder, uint Unknown1) { builder.AddUint(1, Unknown1, 0); }
        public static void AddBoneChildren(FlatBufferBuilder builder, VectorOffset BoneChildrenOffset) { builder.AddOffset(2, BoneChildrenOffset.Value, 0); }
        public static VectorOffset CreateBoneChildrenVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
        public static VectorOffset CreateBoneChildrenVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
        public static void StartBoneChildrenVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
        public static void AddBounding(FlatBufferBuilder builder, Offset<BoundingBox> BoundingOffset) { builder.AddStruct(3, BoundingOffset.Value, 0); }
        public static Offset<CollisionGroup> EndCollisionGroup(FlatBufferBuilder builder)
        {
            int o = builder.EndObject();
            return new Offset<CollisionGroup>(o);
        }
    };

    public struct BoundingBox : IFlatbufferObject
    {
        private Struct __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public BoundingBox __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public float MinX { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
        public float MinY { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
        public float MinZ { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
        public float MaxX { get { return __p.bb.GetFloat(__p.bb_pos + 12); } }
        public float MaxY { get { return __p.bb.GetFloat(__p.bb_pos + 16); } }
        public float MaxZ { get { return __p.bb.GetFloat(__p.bb_pos + 20); } }

        public static Offset<BoundingBox> CreateBoundingBox(FlatBufferBuilder builder, float MinX, float MinY, float MinZ, float MaxX, float MaxY, float MaxZ)
        {
            builder.Prep(4, 24);
            builder.PutFloat(MaxZ);
            builder.PutFloat(MaxY);
            builder.PutFloat(MaxX);
            builder.PutFloat(MinZ);
            builder.PutFloat(MinY);
            builder.PutFloat(MinX);
            return new Offset<BoundingBox>(builder.Offset);
        }
    };

    public struct Vector3 : IFlatbufferObject
    {
        private Struct __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Vector3 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
        public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
        public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }

        public static Offset<Vector3> CreateVector3(FlatBufferBuilder builder, float X, float Y, float Z)
        {
            builder.Prep(4, 12);
            builder.PutFloat(Z);
            builder.PutFloat(Y);
            builder.PutFloat(X);
            return new Offset<Vector3>(builder.Offset);
        }
    };

    public struct ColorRGB32 : IFlatbufferObject
    {
        private Struct __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public ColorRGB32 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public float R { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
        public float G { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
        public float B { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }

        public static Offset<ColorRGB32> CreateColorRGB32(FlatBufferBuilder builder, float R, float G, float B)
        {
            builder.Prep(4, 12);
            builder.PutFloat(B);
            builder.PutFloat(G);
            builder.PutFloat(R);
            return new Offset<ColorRGB32>(builder.Offset);
        }
    };

    public struct Vector4 : IFlatbufferObject
    {
        private Struct __p;
        public ByteBuffer ByteBuffer { get { return __p.bb; } }
        public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
        public Vector4 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }

        public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
        public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
        public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
        public float W { get { return __p.bb.GetFloat(__p.bb_pos + 12); } }

        public static Offset<Vector4> CreateVector4(FlatBufferBuilder builder, float X, float Y, float Z, float W)
        {
            builder.Prep(4, 16);
            builder.PutFloat(W);
            builder.PutFloat(Z);
            builder.PutFloat(Y);
            builder.PutFloat(X);
            return new Offset<Vector4>(builder.Offset);
        }
    };
}
