version bump

src/SharpGLTF.Core/SharpGLTF.Core.csproj

@@ -12,7 +12,7 @@
     <Description>SharpGLTF is a C# library for reading and writing glTF2 3D models</Description>
     <Copyright>Copyright (c) 2019 Vicente Penades</Copyright>
     <PackageTags>C# glTF 3D</PackageTags>
-    <Version>1.0.0-alpha0010</Version>
+    <Version>1.0.0-alpha0011</Version>
     <LangVersion>latest</LangVersion>
     <DebugSymbols>true</DebugSymbols>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>    

src/SharpGLTF.Toolkit/SharpGLTF.Toolkit.csproj

@@ -12,7 +12,7 @@
     <Description>SharpGLTF.Toolkit extends SharpGLTF library with useful tools and helper classes.</Description>
     <Copyright>Copyright (c) 2019 Vicente Penades</Copyright>
     <PackageTags>C# glTF 3D</PackageTags>
-    <Version>1.0.0-alpha0010</Version>
+    <Version>1.0.0-alpha0011</Version>
     <LangVersion>latest</LangVersion>
     <DebugSymbols>true</DebugSymbols>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>

tests/SharpGLTF.Tests/AssemblyAPITests.cs

@@ -76,7 +76,7 @@ namespace SharpGLTF
 
             TestContext.CurrentContext.AttachText($"API.Core.{Schema2.Asset.AssemblyInformationalVersion}.txt", API);
 
-            _CheckBackwardsCompatibility("API.Core.1.0.0-alpha0009.txt", API);
+            _CheckBackwardsCompatibility("API.Core.1.0.0-alpha0010.txt", API);
         }
 
         [Test(Description = "Checks if we have introduced a breaking change between the current and previous API")]
@@ -90,7 +90,7 @@ namespace SharpGLTF
 
             TestContext.CurrentContext.AttachText($"API.Toolkit.{Schema2.Asset.AssemblyInformationalVersion}.txt", API);
 
-            _CheckBackwardsCompatibility("API.Toolkit.1.0.0-alpha0009.txt", API);
+            _CheckBackwardsCompatibility("API.Toolkit.1.0.0-alpha0010.txt", API);
         }
 
         private static void _CheckBackwardsCompatibility(string referenceAPIFile, string[] newLines)

tests/SharpGLTF.Tests/Assets/API.Core.1.0.0-alpha0010.txt

@@ -0,0 +1,894 @@
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Quaternion> (IEnumerable<ValueTuple<Single,Quaternion>>, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Quaternion> (IEnumerable<ValueTuple<Single,ValueTuple<Quaternion,Quaternion,Quaternion>>>) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Single[]> (IEnumerable<ValueTuple<Single,Single[]>>, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Single[]> (IEnumerable<ValueTuple<Single,ValueTuple<Single[],Single[],Single[]>>>) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<SparseWeight8> (IEnumerable<ValueTuple<Single,SparseWeight8>>, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<SparseWeight8> (IEnumerable<ValueTuple<Single,ValueTuple<SparseWeight8,SparseWeight8,SparseWeight8>>>) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Vector3> (IEnumerable<ValueTuple<Single,ValueTuple<Vector3,Vector3,Vector3>>>) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION CreateSampler ICurveSampler<Vector3> (IEnumerable<ValueTuple<Single,Vector3>>, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:EXTENSION FindPairContainingOffset ValueTuple<T,T,Single> (IEnumerable<ValueTuple<Single,T>>, Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC CreateHermitePointWeights ValueTuple<Single,Single,Single,Single> (Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC CreateHermiteTangentWeights ValueTuple<Single,Single,Single,Single> (Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC CreateTangent Quaternion (Quaternion, Quaternion, Single=1) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC CreateTangent Single[] (Single[], Single[], Single=1) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC CreateTangent Vector3 (Vector3, Vector3, Single=1) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC FindPairContainingOffset ValueTuple<Single,Single,Single> (IEnumerable<Single>, Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC InterpolateCubic Quaternion (Quaternion, Quaternion, Quaternion, Quaternion, Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC InterpolateCubic Single[] (Single[], Single[], Single[], Single[], Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC InterpolateCubic Vector3 (Vector3, Vector3, Vector3, Vector3, Single) } }
+NS SharpGLTF.Animations { CLASS:STATIC SamplerFactory { METHOD:STATIC InterpolateLinear Single[] (Single[], Single[], Single) } }
+NS SharpGLTF.Animations { INTERFACE IConvertibleCurve<T> { METHOD:ABSTRACT ToLinearCurve IReadOnlyDictionary<Single,T> () } }
+NS SharpGLTF.Animations { INTERFACE IConvertibleCurve<T> { METHOD:ABSTRACT ToSplineCurve IReadOnlyDictionary<Single,ValueTuple<T,T,T>> () } }
+NS SharpGLTF.Animations { INTERFACE IConvertibleCurve<T> { METHOD:ABSTRACT ToStepCurve IReadOnlyDictionary<Single,T> () } }
+NS SharpGLTF.Animations { INTERFACE IConvertibleCurve<T> { METHOD:GET:ABSTRACT MaxDegree Int32 } }
+NS SharpGLTF.Animations { INTERFACE ICurveSampler<T> { METHOD:ABSTRACT GetPoint T (Single) } }
+NS SharpGLTF.IO { CLASS JsonDictionary { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING Dictionary<String,Object> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING ICollection } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING ICollection<KeyValuePair<String,Object>> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IDeserializationCallback } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IDictionary } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IDictionary<String,Object> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IEnumerable } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IEnumerable<KeyValuePair<String,Object>> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IReadOnlyCollection<KeyValuePair<String,Object>> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING IReadOnlyDictionary<String,Object> } }
+NS SharpGLTF.IO { CLASS JsonDictionary { USING ISerializable } }
+NS SharpGLTF.IO { CLASS JsonList { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.IO { CLASS JsonList { USING ICollection } }
+NS SharpGLTF.IO { CLASS JsonList { USING ICollection<Object> } }
+NS SharpGLTF.IO { CLASS JsonList { USING IEnumerable } }
+NS SharpGLTF.IO { CLASS JsonList { USING IEnumerable<Object> } }
+NS SharpGLTF.IO { CLASS JsonList { USING IList } }
+NS SharpGLTF.IO { CLASS JsonList { USING IList<Object> } }
+NS SharpGLTF.IO { CLASS JsonList { USING IReadOnlyCollection<Object> } }
+NS SharpGLTF.IO { CLASS JsonList { USING IReadOnlyList<Object> } }
+NS SharpGLTF.IO { CLASS JsonList { USING List<Object> } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD Validate IEnumerable<Exception> () } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:ABSTRACT DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:ABSTRACT SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC DeserializePropertyDictionary Void (JsonReader, IDictionary<String,T>) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC DeserializePropertyList Void (JsonReader, IList<T>) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC DeserializePropertyValue T (JsonReader) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC DeserializeUnknownObject Object (JsonReader) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, IReadOnlyDictionary<String,T>) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, IReadOnlyList<T>, Nullable<Int32>=1) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Boolean>, Nullable<Boolean>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Double>, Nullable<Double>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Int32>, Nullable<Int32>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Matrix4x4>, Nullable<Matrix4x4>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Quaternion>, Nullable<Quaternion>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Single>, Nullable<Single>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Vector2>, Nullable<Vector2>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Vector3>, Nullable<Vector3>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Nullable<Vector4>, Nullable<Vector4>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializeProperty Void (JsonWriter, String, Object) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializePropertyEnumSymbol Void (JsonWriter, String, Nullable<T>, Nullable<T>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializePropertyEnumValue Void (JsonWriter, String, Nullable<T>, Nullable<T>=null) } }
+NS SharpGLTF.IO { CLASS:ABSTRACT JsonSerializable { METHOD:PROTECTED:STATIC SerializePropertyObject Void (JsonWriter, String, T) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsColorArray ColorArray () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsIntegerArray IntegerArray () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsMatrix4x4Array Matrix4x4Array () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsMultiArray MultiArray (Int32) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsQuaternionArray QuaternionArray () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsScalarArray ScalarArray () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsVector2Array Vector2Array () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsVector3Array Vector3Array () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsVector4Array Vector4Array () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:CONSTRUCTOR (ArraySegment<Byte>, MemoryAccessInfo) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:CONSTRUCTOR (MemoryAccessInfo) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:GET Attribute MemoryAccessInfo } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:GET Data ArraySegment<Byte> } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:STATIC CreateColorSparseArray IList<Vector4> (MemoryAccessor, IntegerArray, MemoryAccessor) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:STATIC CreateScalarSparseArray IList<Single> (MemoryAccessor, IntegerArray, MemoryAccessor) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:STATIC CreateVector2SparseArray IList<Vector2> (MemoryAccessor, IntegerArray, MemoryAccessor) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:STATIC CreateVector3SparseArray IList<Vector3> (MemoryAccessor, IntegerArray, MemoryAccessor) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD:STATIC CreateVector4SparseArray IList<Vector4> (MemoryAccessor, IntegerArray, MemoryAccessor) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD Fill Void (IEnumerable<Vector4>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, Int32=4, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, Int32=4, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, Int32=4, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:GET:VIRTUAL Item Vector4 } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:SET:VIRTUAL Item Vector4 } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:VIRTUAL Contains Boolean (Vector4) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:VIRTUAL CopyTo Void (Vector4[], Int32) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:VIRTUAL GetEnumerator IEnumerator<Vector4> () } }
+NS SharpGLTF.Memory { STRUCT ColorArray { METHOD:VIRTUAL IndexOf Int32 (Vector4) } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING ICollection<Vector4> } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING IEnumerable<Vector4> } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING IList<Vector4> } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING IReadOnlyCollection<Vector4> } }
+NS SharpGLTF.Memory { STRUCT ColorArray { USING IReadOnlyList<Vector4> } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD Fill Void (IEnumerable<Int32>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD Fill Void (IEnumerable<UInt32>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, IndexEncodingType=UNSIGNED_INT) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, IndexEncodingType) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, IndexEncodingType) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:GET:VIRTUAL Item UInt32 } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:SET:VIRTUAL Item UInt32 } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:VIRTUAL Contains Boolean (UInt32) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:VIRTUAL CopyTo Void (UInt32[], Int32) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:VIRTUAL GetEnumerator IEnumerator<UInt32> () } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { METHOD:VIRTUAL IndexOf Int32 (UInt32) } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING ICollection<UInt32> } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING IEnumerable<UInt32> } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING IList<UInt32> } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING IReadOnlyCollection<UInt32> } }
+NS SharpGLTF.Memory { STRUCT IntegerArray { USING IReadOnlyList<UInt32> } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD Fill Void (IEnumerable<Matrix4x4>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType, Boolean) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:GET:VIRTUAL Item Matrix4x4 } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:SET:VIRTUAL Item Matrix4x4 } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:VIRTUAL Contains Boolean (Matrix4x4) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:VIRTUAL CopyTo Void (Matrix4x4[], Int32) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:VIRTUAL GetEnumerator IEnumerator<Matrix4x4> () } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { METHOD:VIRTUAL IndexOf Int32 (Matrix4x4) } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING ICollection<Matrix4x4> } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING IEnumerable<Matrix4x4> } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING IList<Matrix4x4> } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING IReadOnlyCollection<Matrix4x4> } }
+NS SharpGLTF.Memory { STRUCT Matrix4x4Array { USING IReadOnlyList<Matrix4x4> } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD ByteOffset Int32 } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD ByteStride Int32 } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD Dimensions DimensionType } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD Encoding EncodingType } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD ItemsCount Int32 } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD Name String } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { FIELD Normalized Boolean } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD Slice MemoryAccessInfo (Int32, Int32) } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:CONSTRUCTOR (String, Int32, Int32, Int32, DimensionType, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:GET IsValidIndexer Boolean } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:GET IsValidVertexAttribute Boolean } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:GET PaddedByteLength Int32 } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:STATIC Create MemoryAccessInfo[] (params String[]) } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:STATIC CreateDefaultElement MemoryAccessInfo (String) } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:STATIC SetInterleavedInfo Int32 (MemoryAccessInfo[], Int32, Int32) } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:STATIC Slice MemoryAccessInfo[] (MemoryAccessInfo[], Int32, Int32) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD CopyItemTo Void (Int32, Single[]) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD Fill Void (IEnumerable<Single[]>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, Int32, EncodingType, Boolean) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:GET Dimensions Int32 } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:GET:VIRTUAL Item Single[] } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:SET:VIRTUAL Item Single[] } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:VIRTUAL Contains Boolean (Single[]) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:VIRTUAL CopyTo Void (Single[][], Int32) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:VIRTUAL GetEnumerator IEnumerator<Single[]> () } }
+NS SharpGLTF.Memory { STRUCT MultiArray { METHOD:VIRTUAL IndexOf Int32 (Single[]) } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING ICollection<Single[]> } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING IEnumerable<Single[]> } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING IList<Single[]> } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING IReadOnlyCollection<Single[]> } }
+NS SharpGLTF.Memory { STRUCT MultiArray { USING IReadOnlyList<Single[]> } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD Fill Void (IEnumerable<Quaternion>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType, Boolean) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:GET:VIRTUAL Item Quaternion } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:SET:VIRTUAL Item Quaternion } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:VIRTUAL Contains Boolean (Quaternion) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:VIRTUAL CopyTo Void (Quaternion[], Int32) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:VIRTUAL GetEnumerator IEnumerator<Quaternion> () } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { METHOD:VIRTUAL IndexOf Int32 (Quaternion) } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING ICollection<Quaternion> } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING IEnumerable<Quaternion> } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING IList<Quaternion> } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING IReadOnlyCollection<Quaternion> } }
+NS SharpGLTF.Memory { STRUCT QuaternionArray { USING IReadOnlyList<Quaternion> } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD Fill Void (IEnumerable<Single>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:GET:VIRTUAL Item Single } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:SET:VIRTUAL Item Single } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:VIRTUAL Contains Boolean (Single) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:VIRTUAL CopyTo Void (Single[], Int32) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:VIRTUAL GetEnumerator IEnumerator<Single> () } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { METHOD:VIRTUAL IndexOf Int32 (Single) } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING ICollection<Single> } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING IEnumerable<Single> } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING IList<Single> } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING IReadOnlyCollection<Single> } }
+NS SharpGLTF.Memory { STRUCT ScalarArray { USING IReadOnlyList<Single> } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:CONSTRUCTOR (IList<T>, IList<T>, IntegerArray) } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:GET:VIRTUAL IsReadOnly Boolean } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:GET:VIRTUAL Item T } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:SET:VIRTUAL Item T } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:VIRTUAL Contains Boolean (T) } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:VIRTUAL CopyTo Void (T[], Int32) } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:VIRTUAL GetEnumerator IEnumerator<T> () } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { METHOD:VIRTUAL IndexOf Int32 (T) } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING ICollection<T> } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING IEnumerable<T> } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING IList<T> } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING IReadOnlyCollection<T> } }
+NS SharpGLTF.Memory { STRUCT SparseArray<T> { USING IReadOnlyList<T> } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD Fill Void (IEnumerable<Vector2>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:GET:VIRTUAL Item Vector2 } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:SET:VIRTUAL Item Vector2 } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:VIRTUAL Contains Boolean (Vector2) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:VIRTUAL CopyTo Void (Vector2[], Int32) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:VIRTUAL GetEnumerator IEnumerator<Vector2> () } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { METHOD:VIRTUAL IndexOf Int32 (Vector2) } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING ICollection<Vector2> } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING IEnumerable<Vector2> } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING IList<Vector2> } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING IReadOnlyCollection<Vector2> } }
+NS SharpGLTF.Memory { STRUCT Vector2Array { USING IReadOnlyList<Vector2> } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD Fill Void (IEnumerable<Vector3>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:GET:VIRTUAL Item Vector3 } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:SET:VIRTUAL Item Vector3 } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:VIRTUAL Contains Boolean (Vector3) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:VIRTUAL CopyTo Void (Vector3[], Int32) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:VIRTUAL GetEnumerator IEnumerator<Vector3> () } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { METHOD:VIRTUAL IndexOf Int32 (Vector3) } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING ICollection<Vector3> } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING IEnumerable<Vector3> } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING IList<Vector3> } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING IReadOnlyCollection<Vector3> } }
+NS SharpGLTF.Memory { STRUCT Vector3Array { USING IReadOnlyList<Vector3> } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD Fill Void (IEnumerable<Vector4>, Int32=0) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:CONSTRUCTOR (ArraySegment<Byte>, Int32=0, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:CONSTRUCTOR (Byte[], Int32, Int32, Int32, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:GET:VIRTUAL Count Int32 } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:GET:VIRTUAL Item Vector4 } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:SET:VIRTUAL Item Vector4 } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:VIRTUAL Contains Boolean (Vector4) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:VIRTUAL CopyTo Void (Vector4[], Int32) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:VIRTUAL GetEnumerator IEnumerator<Vector4> () } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { METHOD:VIRTUAL IndexOf Int32 (Vector4) } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING ICollection<Vector4> } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING IEnumerable } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING IEnumerable<Vector4> } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING IList<Vector4> } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING IReadOnlyCollection<Vector4> } }
+NS SharpGLTF.Memory { STRUCT Vector4Array { USING IReadOnlyList<Vector4> } }
+NS SharpGLTF.Schema2 { CLASS ReadSettings { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Schema2 { CLASS ReadSettings { METHOD:GET FileReader AssetReader } }
+NS SharpGLTF.Schema2 { CLASS ReadSettings { METHOD:SET FileReader AssetReader } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:GET BinaryMode Boolean } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:GET FileWriter AssetWriter } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:GET ImageWriting ImageWriteMode } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:GET JsonFormatting Formatting } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:GET MergeBuffers Boolean } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:SET BinaryMode Boolean } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:SET FileWriter AssetWriter } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:SET ImageWriting ImageWriteMode } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:SET JsonFormatting Formatting } }
+NS SharpGLTF.Schema2 { CLASS WriteSettings { METHOD:SET MergeBuffers Boolean } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD GetExtension T () } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD RemoveExtensions Void () } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD RemoveExtensions Void (T) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD SetExtension Void (T) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD TryUseExtrasAsDictionary JsonDictionary (Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD TryUseExtrasAsList JsonList (Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:GET Extensions IReadOnlyCollection<JsonSerializable> } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:GET Extras Object } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:PROTECTED:STATIC Flatten IEnumerable<ExtraProperties> (ExtraProperties) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT ExtraProperties { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:GET Name String } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:GET:VIRTUAL LogicalParent ModelRoot } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:PROTECTED SharesLogicalParent Boolean (params LogicalChildOfRoot[]) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { METHOD:STATIC RenameLogicalElements Void (IEnumerable<T>, String) } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:ABSTRACT LogicalChildOfRoot { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsColorArray IList<Vector4> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsIndicesArray IntegerArray () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsMatrix4x4Array Matrix4x4Array () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsMultiArray IList<Single[]> (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsQuaternionArray IList<Quaternion> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsScalarArray IList<Single> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsVector2Array IList<Vector2> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsVector3Array IList<Vector3> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsVector4Array IList<Vector4> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD SetData Void (BufferView, Int32, Int32, DimensionType, EncodingType, Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD SetIndexData Void (BufferView, Int32, Int32, IndexEncodingType) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD SetIndexData Void (MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD SetVertexData Void (BufferView, Int32, Int32, DimensionType=VEC3, EncodingType=FLOAT, Boolean=False) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD SetVertexData Void (MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD TryGetVertexBytes ArraySegment<Byte> (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD UpdateBounds Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET ByteOffset Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET Count Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET Dimensions DimensionType } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET Encoding EncodingType } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET IsSparse Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET ItemByteSize Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET Normalized Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:GET SourceBufferView BufferView } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { METHOD:GET Count Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparse { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseIndices { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseIndices { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseIndices { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseIndices { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseValues { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseValues { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseValues { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AccessorSparseValues { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateMorphChannel Void (Node, AnimationInterpolationMode, IReadOnlyDictionary<Single,SparseWeight8>, Int32, Boolean=True) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateRotationChannel Void (Node, IReadOnlyDictionary<Single,Quaternion>, Boolean=True) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateRotationChannel Void (Node, IReadOnlyDictionary<Single,ValueTuple<Quaternion,Quaternion,Quaternion>>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateScaleChannel Void (Node, IReadOnlyDictionary<Single,ValueTuple<Vector3,Vector3,Vector3>>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateScaleChannel Void (Node, IReadOnlyDictionary<Single,Vector3>, Boolean=True) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateTranslationChannel Void (Node, IReadOnlyDictionary<Single,ValueTuple<Vector3,Vector3,Vector3>>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD CreateTranslationChannel Void (Node, IReadOnlyDictionary<Single,Vector3>, Boolean=True) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindMorphSampler IAnimationSampler<Single[]> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindRotationSampler IAnimationSampler<Quaternion> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindScaleSampler IAnimationSampler<Vector3> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindSparseMorphSampler IAnimationSampler<SparseWeight8> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindTranslationSampler IAnimationSampler<Vector3> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD GetLocalTransform AffineTransform (Node, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD GetMorphWeights IReadOnlyList<Single> (Node, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD GetSparseMorphWeights SparseWeight8 (Node, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD:GET Duration Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:GET Copyright String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:GET Generator String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:GET MinVersion Version } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:GET Version Version } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:GET:STATIC AssemblyInformationalVersion String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:SET Copyright String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { METHOD:SET Generator String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Asset { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { METHOD:CONSTRUCTOR (Object, IntPtr) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { METHOD:VIRTUAL BeginInvoke IAsyncResult (String, AsyncCallback, Object) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { METHOD:VIRTUAL EndInvoke ArraySegment<Byte> (IAsyncResult) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { METHOD:VIRTUAL Invoke ArraySegment<Byte> (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { USING Delegate } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { USING ICloneable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { USING ISerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetReader { USING MulticastDelegate } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { METHOD:CONSTRUCTOR (Object, IntPtr) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { METHOD:VIRTUAL BeginInvoke IAsyncResult (String, ArraySegment<Byte>, AsyncCallback, Object) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { METHOD:VIRTUAL EndInvoke Void (IAsyncResult) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { METHOD:VIRTUAL Invoke Void (String, ArraySegment<Byte>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { USING Delegate } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { USING ICloneable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { USING ISerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED AssetWriter { USING MulticastDelegate } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { METHOD:GET Content Byte[] } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Buffer { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD FindAccessors IEnumerable<Accessor> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD IsInterleaved Boolean (IEnumerable<Accessor>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:GET ByteStride Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:GET Content ArraySegment<Byte> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:GET DeviceBufferTarget Nullable<BufferMode> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED BufferView { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD SetOrthographicMode Void (Single, Single, Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD SetPerspectiveMode Void (Nullable<Single>, Single, Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:GET Matrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:GET Settings ICamera } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET XMag Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET YMag Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET ZFar Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET ZNear Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET:VIRTUAL IsOrthographic Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET:VIRTUAL IsPerspective Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:GET:VIRTUAL Matrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { METHOD:STATIC CheckParameters Void (Single, Single, Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { USING ICamera } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraOrthographic { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET AspectRatio Nullable<Single> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET VerticalFOV Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET ZFar Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET ZNear Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET:VIRTUAL IsOrthographic Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET:VIRTUAL IsPerspective Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:GET:VIRTUAL Matrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { METHOD:STATIC CheckParameters Void (Nullable<Single>, Single, Single, Single=∞) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { USING ICamera } }
+NS SharpGLTF.Schema2 { CLASS:SEALED CameraPerspective { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD GetImageContent ArraySegment<Byte> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD SetSatelliteContent Void (Byte[]) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD SetSatelliteFile Void (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD TransferToInternalBuffer Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET FileExtension String } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET IsDds Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET IsJpeg Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET IsPng Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET IsSatelliteFile Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET IsWebp Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Image { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD FindChannel Nullable<MaterialChannel> (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD InitializePBRMetallicRoughness Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD InitializePBRSpecularGlossiness Void (Boolean=False) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD InitializeUnlit Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET Alpha AlphaMode } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET AlphaCutoff Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET Channels IEnumerable<MaterialChannel> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET DoubleSided Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:GET Unlit Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:SET Alpha AlphaMode } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:SET AlphaCutoff Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { METHOD:SET DoubleSided Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Material { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD CreatePrimitive MeshPrimitive () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:GET MorphWeights IReadOnlyList<Single> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:GET Primitives IReadOnlyList<MeshPrimitive> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:GET VisualParents IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Mesh { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetBufferViews IEnumerable<BufferView> (Boolean, Boolean, Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetIndexAccessor Accessor () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetIndices IntegerArray () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetMorphTargetAccessors IReadOnlyDictionary<String,Accessor> (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetVertexAccessor Accessor (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetVertexAccessorsByBuffer IReadOnlyList<KeyValuePair<String,Accessor>> (BufferView) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD GetVertices MemoryAccessor (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD SetIndexAccessor Void (Accessor) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD SetMorphTargetAccessors Void (Int32, IReadOnlyDictionary<String,Accessor>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD SetVertexAccessor Void (String, Accessor) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET DrawPrimitiveType PrimitiveType } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET IndexAccessor Accessor } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET Material Material } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET MorphTargetsCount Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET VertexAccessors IReadOnlyDictionary<String,Accessor> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:GET:VIRTUAL LogicalParent Mesh } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:SET DrawPrimitiveType PrimitiveType } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:SET IndexAccessor Accessor } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { METHOD:SET Material Material } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED MeshPrimitive { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateAccessor Accessor (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateAnimation Animation (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateBuffer Buffer (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateCamera Camera (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateImage Image (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateMaterial Material (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateMesh Mesh (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreatePunctualLight PunctualLight (PunctualLightType) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreatePunctualLight PunctualLight (String, PunctualLightType) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD CreateSkin Skin (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD DeepClone ModelRoot () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD GetJSON String (Formatting) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD IsolateMemory Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD MergeBuffers Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD MergeImages Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD SaveGLB Void (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD SaveGLTF Void (String, Formatting=None) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseBuffer Buffer (Byte[]) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseBufferView BufferView (ArraySegment<Byte>, Int32=0, Nullable<BufferMode>=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseBufferView BufferView (Buffer, Int32=0, Nullable<Int32>=null, Int32=0, Nullable<BufferMode>=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseBufferView BufferView (Byte[], Int32=0, Nullable<Int32>=null, Int32=0, Nullable<BufferMode>=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseImage Image (ArraySegment<Byte>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseScene Scene (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseScene Scene (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseTexture Texture (Image, Image, TextureSampler=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseTexture Texture (Image, TextureSampler=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseTextureSampler TextureSampler (TextureWrapMode, TextureWrapMode, TextureMipMapFilter, TextureInterpolationFilter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD Write Void (WriteSettings, String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD WriteGLB ArraySegment<Byte> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD WriteGLB Void (Stream) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD WriteToDictionary Dictionary<String,ArraySegment<Byte>> (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET Asset Asset } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET DefaultScene Scene } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET ExtensionsRequired IEnumerable<String> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET ExtensionsUsed IEnumerable<String> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET IncompatibleExtensions IEnumerable<String> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalAccessors IReadOnlyList<Accessor> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalAnimations IReadOnlyList<Animation> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalBuffers IReadOnlyList<Buffer> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalBufferViews IReadOnlyList<BufferView> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalCameras IReadOnlyList<Camera> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalImages IReadOnlyList<Image> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalMaterials IReadOnlyList<Material> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalMeshes IReadOnlyList<Mesh> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalNodes IReadOnlyList<Node> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalPunctualLights IReadOnlyList<PunctualLight> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalScenes IReadOnlyList<Scene> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalSkins IReadOnlyList<Skin> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalTextures IReadOnlyList<Texture> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:GET LogicalTextureSamplers IReadOnlyList<TextureSampler> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:PROTECTED:VIRTUAL GetLogicalChildren IEnumerable<ExtraProperties> () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:SET DefaultScene Scene } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC CreateModel ModelRoot () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC Load ModelRoot (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC ParseGLB ModelRoot (ArraySegment<Byte>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC ParseGLTF ModelRoot (String, ReadSettings) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC Read ModelRoot (Stream, ReadSettings) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC ReadFromDictionary ModelRoot (Dictionary<String,ArraySegment<Byte>>, String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC ReadGLB ModelRoot (Stream, ReadSettings) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD:STATIC ReadGLTF ModelRoot (Stream, ReadSettings) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetGeometryTransform IGeometryTransform () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetGeometryTransform IGeometryTransform (Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetLocalTransform AffineTransform (Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetWorldMatrix Matrix4x4 (Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD UpdateGeometryTransform Void (IGeometryTransform, Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET Camera Camera } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET IsSkinJoint Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET IsSkinSkeleton Boolean } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET LocalMatrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET LocalTransform AffineTransform } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET Mesh Mesh } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET MorphWeights IReadOnlyList<Single> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET PunctualLight PunctualLight } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET Skin Skin } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET VisualParent Node } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET VisualRoot Node } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET VisualScenes IEnumerable<Scene> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET WorldMatrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:GET:VIRTUAL VisualChildren IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET Camera Camera } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET LocalMatrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET LocalTransform AffineTransform } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET Mesh Mesh } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET MorphWeights IReadOnlyList<Single> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET PunctualLight PunctualLight } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET Skin Skin } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:SET WorldMatrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:STATIC FindNodesUsingMesh IEnumerable<Node> (Mesh) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:STATIC FindNodesUsingSkin IEnumerable<Node> (Skin) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:STATIC Flatten IEnumerable<Node> (IVisualNodeContainer) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD:VIRTUAL CreateNode Node (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { USING IVisualNodeContainer } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD SetColor Void (Vector3, Single=1, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD SetSpotCone Void (Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET Color Vector3 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET InnerConeAngle Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET Intensity Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET LightType PunctualLightType } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET OuterConeAngle Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET Range Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:GET:STATIC LocalDirection Vector3 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:SET Color Vector3 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:SET Intensity Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { METHOD:SET Range Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED PunctualLight { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { METHOD:GET:VIRTUAL VisualChildren IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { METHOD:VIRTUAL CreateNode Node (String=null) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { USING IVisualNodeContainer } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Scene { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD BindJoints Void (Matrix4x4, params Node[]) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD BindJoints Void (params Node[]) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD BindJoints Void (ValueTuple[]<Node,Matrix4x4>) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD GetInverseBindMatricesAccessor Accessor () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD GetJoint ValueTuple<Node,Matrix4x4> (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:GET JointsCount Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:GET Skeleton Node } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:GET VisualParents IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD:SET Skeleton Node } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD ClearImages Void () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD SetImage Void (Image) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD SetImages Void (Image, Image) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET FallbackImage Image } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET Image Image } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET PrimaryImage Image } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET Sampler TextureSampler } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:SET Image Image } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:SET Sampler TextureSampler } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:GET MagFilter TextureInterpolationFilter } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:GET MinFilter TextureMipMapFilter } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:GET WrapS TextureWrapMode } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:GET WrapT TextureWrapMode } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureSampler { USING LogicalChildOfRoot } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:GET Offset Vector2 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:GET Rotation Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:GET Scale Vector2 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:GET TextureCoordinateOverride Nullable<Int32> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:PROTECTED:VIRTUAL DeserializeProperty Void (String, JsonReader) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:PROTECTED:VIRTUAL SerializeProperties Void (JsonWriter) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:SET Offset Vector2 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:SET Rotation Single } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:SET Scale Vector2 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { METHOD:SET TextureCoordinateOverride Nullable<Int32> } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { USING ExtraProperties } }
+NS SharpGLTF.Schema2 { CLASS:SEALED TextureTransform { USING JsonSerializable } }
+NS SharpGLTF.Schema2 { ENUM AlphaMode { BLEND=2 } }
+NS SharpGLTF.Schema2 { ENUM AlphaMode { MASK=1 } }
+NS SharpGLTF.Schema2 { ENUM AlphaMode { OPAQUE=0 } }
+NS SharpGLTF.Schema2 { ENUM AnimationInterpolationMode { CUBICSPLINE=2 } }
+NS SharpGLTF.Schema2 { ENUM AnimationInterpolationMode { LINEAR=0 } }
+NS SharpGLTF.Schema2 { ENUM AnimationInterpolationMode { STEP=1 } }
+NS SharpGLTF.Schema2 { ENUM BufferMode { ARRAY_BUFFER=34962 } }
+NS SharpGLTF.Schema2 { ENUM BufferMode { ELEMENT_ARRAY_BUFFER=34963 } }
+NS SharpGLTF.Schema2 { ENUM CameraType { orthographic=1 } }
+NS SharpGLTF.Schema2 { ENUM CameraType { perspective=0 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { MAT2=4 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { MAT3=5 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { MAT4=6 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { SCALAR=0 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { VEC2=1 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { VEC3=2 } }
+NS SharpGLTF.Schema2 { ENUM DimensionType { VEC4=3 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { BYTE=5120 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { FLOAT=5126 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { SHORT=5122 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { UNSIGNED_BYTE=5121 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { UNSIGNED_INT=5125 } }
+NS SharpGLTF.Schema2 { ENUM EncodingType { UNSIGNED_SHORT=5123 } }
+NS SharpGLTF.Schema2 { ENUM ImageWriteMode { BufferView=1 } }
+NS SharpGLTF.Schema2 { ENUM ImageWriteMode { Embedded=2 } }
+NS SharpGLTF.Schema2 { ENUM ImageWriteMode { SatelliteFile=0 } }
+NS SharpGLTF.Schema2 { ENUM IndexEncodingType { UNSIGNED_BYTE=5121 } }
+NS SharpGLTF.Schema2 { ENUM IndexEncodingType { UNSIGNED_INT=5125 } }
+NS SharpGLTF.Schema2 { ENUM IndexEncodingType { UNSIGNED_SHORT=5123 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { LINE_LOOP=2 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { LINE_STRIP=3 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { LINES=1 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { POINTS=0 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { TRIANGLE_FAN=6 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { TRIANGLE_STRIP=5 } }
+NS SharpGLTF.Schema2 { ENUM PrimitiveType { TRIANGLES=4 } }
+NS SharpGLTF.Schema2 { ENUM PropertyPath { rotation=1 } }
+NS SharpGLTF.Schema2 { ENUM PropertyPath { scale=2 } }
+NS SharpGLTF.Schema2 { ENUM PropertyPath { translation=0 } }
+NS SharpGLTF.Schema2 { ENUM PropertyPath { weights=3 } }
+NS SharpGLTF.Schema2 { ENUM PunctualLightType { Directional=0 } }
+NS SharpGLTF.Schema2 { ENUM PunctualLightType { Point=1 } }
+NS SharpGLTF.Schema2 { ENUM PunctualLightType { Spot=2 } }
+NS SharpGLTF.Schema2 { ENUM TextureInterpolationFilter { DEFAULT=0 } }
+NS SharpGLTF.Schema2 { ENUM TextureInterpolationFilter { LINEAR=9729 } }
+NS SharpGLTF.Schema2 { ENUM TextureInterpolationFilter { NEAREST=9728 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { DEFAULT=0 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { LINEAR_MIPMAP_LINEAR=9987 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { LINEAR_MIPMAP_NEAREST=9985 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { LINEAR=9729 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { NEAREST_MIPMAP_LINEAR=9986 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { NEAREST_MIPMAP_NEAREST=9984 } }
+NS SharpGLTF.Schema2 { ENUM TextureMipMapFilter { NEAREST=9728 } }
+NS SharpGLTF.Schema2 { ENUM TextureWrapMode { CLAMP_TO_EDGE=33071 } }
+NS SharpGLTF.Schema2 { ENUM TextureWrapMode { MIRRORED_REPEAT=33648 } }
+NS SharpGLTF.Schema2 { ENUM TextureWrapMode { REPEAT=10497 } }
+NS SharpGLTF.Schema2 { INTERFACE IAnimationSampler<T> { METHOD:ABSTRACT CreateCurveSampler ICurveSampler<T> () } }
+NS SharpGLTF.Schema2 { INTERFACE IAnimationSampler<T> { METHOD:ABSTRACT GetCubicKeys IEnumerable<ValueTuple<Single,ValueTuple<T,T,T>>> () } }
+NS SharpGLTF.Schema2 { INTERFACE IAnimationSampler<T> { METHOD:ABSTRACT GetLinearKeys IEnumerable<ValueTuple<Single,T>> () } }
+NS SharpGLTF.Schema2 { INTERFACE IAnimationSampler<T> { METHOD:GET:ABSTRACT InterpolationMode AnimationInterpolationMode } }
+NS SharpGLTF.Schema2 { INTERFACE ICamera { METHOD:GET:ABSTRACT IsOrthographic Boolean } }
+NS SharpGLTF.Schema2 { INTERFACE ICamera { METHOD:GET:ABSTRACT IsPerspective Boolean } }
+NS SharpGLTF.Schema2 { INTERFACE ICamera { METHOD:GET:ABSTRACT Matrix Matrix4x4 } }
+NS SharpGLTF.Schema2 { INTERFACE IVisualNodeContainer { METHOD:ABSTRACT CreateNode Node (String=null) } }
+NS SharpGLTF.Schema2 { INTERFACE IVisualNodeContainer { METHOD:GET:ABSTRACT VisualChildren IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD SetTexture Void (Int32, Image, Image=null, TextureWrapMode=REPEAT, TextureWrapMode=REPEAT, TextureMipMapFilter=DEFAULT, TextureInterpolationFilter=DEFAULT) } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD SetTexture Void (Int32, Texture) } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD SetTransform Void (Vector2, Vector2, Single=0, Nullable<Int32>=null) } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET HasDefaultContent Boolean } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET Key String } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET LogicalParent Material } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET Parameter Vector4 } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET Texture Texture } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET TextureCoordinate Int32 } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET TextureSampler TextureSampler } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:GET TextureTransform TextureTransform } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD:SET Parameter Vector4 } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD TransformNormal Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD TransformPosition Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD TransformTangent Vector4 (Vector4, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD Update Void (Int32, Func<Int32,Matrix4x4>, Func<Int32,Matrix4x4>) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD Update Void (Matrix4x4[], Matrix4x4[]) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:CONSTRUCTOR (Int32, Func<Int32,Matrix4x4>, Func<Int32,Matrix4x4>, SparseWeight8, Boolean) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:CONSTRUCTOR (Matrix4x4[], Matrix4x4[], SparseWeight8, Boolean) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:GET SkinMatrices IReadOnlyList<Matrix4x4> } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:GET:VIRTUAL FlipFaces Boolean } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:GET:VIRTUAL Visible Boolean } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:STATIC CalculateInverseBinding Matrix4x4 (Matrix4x4, Matrix4x4) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { USING IGeometryTransform } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { USING MorphTransform } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD TransformNormal Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD TransformPosition Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD TransformTangent Vector4 (Vector4, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD Update Void (Matrix4x4) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:CONSTRUCTOR (Matrix4x4) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:CONSTRUCTOR (Matrix4x4, SparseWeight8, Boolean) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:GET WorldMatrix Matrix4x4 } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:GET:VIRTUAL FlipFaces Boolean } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:GET:VIRTUAL Visible Boolean } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { USING IGeometryTransform } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { USING MorphTransform } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { FIELD:CONST COMPLEMENT_INDEX Int32 } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD Update Void (SparseWeight8, Boolean=False) } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:CONSTRUCTOR (SparseWeight8, Boolean) } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:GET AbsoluteMorphTargets Boolean } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:GET MorphWeights SparseWeight8 } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:PROTECTED MorphVectors Vector3 (Vector3, Vector3[]) } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:PROTECTED MorphVectors Vector4 (Vector4, Vector4[]) } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:VIRTUAL MorphColors Vector4 (Vector4, Vector4[]) } }
+NS SharpGLTF.Transforms { CLASS:STATIC Projection { METHOD:STATIC CreateOrthographicMatrix Matrix4x4 (Single, Single, Single, Single) } }
+NS SharpGLTF.Transforms { CLASS:STATIC Projection { METHOD:STATIC CreatePerspectiveMatrix Matrix4x4 (Single, Single, Single, Single=∞) } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:ABSTRACT MorphColors Vector4 (Vector4, Vector4[]) } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:ABSTRACT TransformNormal Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:ABSTRACT TransformPosition Vector3 (Vector3, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:ABSTRACT TransformTangent Vector4 (Vector4, Vector3[], in SparseWeight8) } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:GET:ABSTRACT FlipFaces Boolean } }
+NS SharpGLTF.Transforms { INTERFACE IGeometryTransform { METHOD:GET:ABSTRACT Visible Boolean } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { FIELD Rotation Quaternion } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { FIELD Scale Vector3 } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { FIELD Translation Vector3 } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:GET IsIdentity Boolean } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:GET IsValid Boolean } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:GET Matrix Matrix4x4 } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:GET:STATIC Identity AffineTransform } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:STATIC Create AffineTransform (Matrix4x4) } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:STATIC Create AffineTransform (Nullable<Vector3>, Nullable<Quaternion>, Nullable<Vector3>) } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:STATIC Evaluate Matrix4x4 (Nullable<Matrix4x4>, Nullable<Vector3>, Nullable<Quaternion>, Nullable<Vector3>) } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:STATIC LocalToWorld Matrix4x4 (Matrix4x4, Matrix4x4) } }
+NS SharpGLTF.Transforms { STRUCT AffineTransform { METHOD:STATIC WorldToLocal Matrix4x4 (Matrix4x4, Matrix4x4) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index0 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index1 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index2 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index3 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index4 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index5 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index6 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Index7 Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight0 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight1 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight2 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight3 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight4 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight5 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight6 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { FIELD:READONLY Weight7 Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD Expand IEnumerable<Single> (Int32) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD GetIndexedWeights IEnumerable<ValueTuple<Int32,Single>> () } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD GetWeightsHashCode Int32 () } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:CONSTRUCTOR (in Vector4, in Vector4) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:CONSTRUCTOR (in Vector4, in Vector4, in Vector4, in Vector4) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:GET Count Int32 } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:GET IsWeightless Boolean } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:GET Item Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:GET WeightSum Single } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Add SparseWeight8 (in SparseWeight8, in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC AreWeightsEqual Boolean (in SparseWeight8, in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Create SparseWeight8 (IEnumerable<Single>) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Create SparseWeight8 (params Single[]) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Create SparseWeight8 (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC InterpolateCubic SparseWeight8 (in SparseWeight8, in SparseWeight8, in SparseWeight8, in SparseWeight8, Single) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC InterpolateLinear SparseWeight8 (in SparseWeight8, in SparseWeight8, Single) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Multiply SparseWeight8 (in SparseWeight8, in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Multiply SparseWeight8 (in SparseWeight8, Single) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC OrderedByIndex SparseWeight8 (in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC OrderedByWeight SparseWeight8 (in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:STATIC Subtract SparseWeight8 (in SparseWeight8, in SparseWeight8) } }
+NS SharpGLTF.Transforms { STRUCT SparseWeight8 { METHOD:VIRTUAL ToString String () } }
+NS SharpGLTF.Validation { CLASS DataException { USING Exception } }
+NS SharpGLTF.Validation { CLASS DataException { USING ISerializable } }
+NS SharpGLTF.Validation { CLASS DataException { USING ModelException } }
+NS SharpGLTF.Validation { CLASS LinkException { USING Exception } }
+NS SharpGLTF.Validation { CLASS LinkException { USING ISerializable } }
+NS SharpGLTF.Validation { CLASS LinkException { USING ModelException } }
+NS SharpGLTF.Validation { CLASS ModelException { USING Exception } }
+NS SharpGLTF.Validation { CLASS ModelException { USING ISerializable } }
+NS SharpGLTF.Validation { CLASS SchemaException { USING Exception } }
+NS SharpGLTF.Validation { CLASS SchemaException { USING ISerializable } }
+NS SharpGLTF.Validation { CLASS SchemaException { USING ModelException } }
+NS SharpGLTF.Validation { CLASS SemanticException { USING Exception } }
+NS SharpGLTF.Validation { CLASS SemanticException { USING ISerializable } }
+NS SharpGLTF.Validation { CLASS SemanticException { USING ModelException } }

tests/SharpGLTF.Tests/Assets/API.Toolkit.1.0.0-alpha0010.txt

@@ -0,0 +1,662 @@
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD GetValueAt T (String, Single) } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD RemoveTrack Void (String) } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD SetTrack Void (String, ICurveSampler<T>) } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD UseTrackBuilder CurveBuilder<T> (String) } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD:GET IsAnimated Boolean } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD:GET Tracks IReadOnlyDictionary<String,ICurveSampler<T>> } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD:GET Value T } }
+NS SharpGLTF.Animations { CLASS AnimatableProperty<T> { METHOD:SET Value T } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD Clear Void () } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD FindSample ValueTuple<_CurveNode<T>,_CurveNode<T>,Single> (Single) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD RemoveKey Void (Single) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD SetCurve Void (ICurveSampler<T>) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD SetIncomingTangent Void (Single, T) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD SetOutgoingTangent Void (Single, T) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD SetPoint Void (Single, T, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithIncomingTangent CurveBuilder<T> (Single, params Single[]) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithIncomingTangent CurveBuilder<T> (Single, T) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithOutgoingTangent CurveBuilder<T> (Single, params Single[]) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithOutgoingTangent CurveBuilder<T> (Single, T) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithPoint CurveBuilder<T> (Single, params Single[]) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD WithPoint CurveBuilder<T> (Single, T, Boolean=True) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:ABSTRACT Clone CurveBuilder<T> () } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:ABSTRACT GetPoint T (Single) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:CONSTRUCTOR (CurveBuilder<T>) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:GET Keys IReadOnlyCollection<Single> } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:GET:VIRTUAL MaxDegree Int32 } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:PROTECTED:ABSTRACT CreateValue T (params Single[]) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { METHOD:PROTECTED:ABSTRACT GetTangent T (T, T) } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { USING IConvertibleCurve<T> } }
+NS SharpGLTF.Animations { CLASS:ABSTRACT CurveBuilder<T> { USING ICurveSampler<T> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddMesh Void (MeshBuilder<TMaterial,TvG,TvM,TvS>, Func<TMaterial,TMaterial>, Func<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>>) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD TransformVertices Void (Func<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>>) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD UsePrimitive PrimitiveBuilder<TMaterial,TvG,TvM,TvS> (TMaterial, Int32=3) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET Primitives IReadOnlyCollection<PrimitiveBuilder<TMaterial,TvG,TvM,TvS>> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET VertexPreprocessor VertexPreprocessor<TvG,TvM,TvS> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Materials IEnumerable<TMaterial> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Name String } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:SET VertexPreprocessor VertexPreprocessor<TvG,TvM,TvS> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:SET:VIRTUAL Name String } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { USING IMeshBuilder<TMaterial> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM,TvS> { USING IMeshBuilder<MaterialBuilder> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM,TvS> { USING MeshBuilder<MaterialBuilder,TvG,TvM,TvS> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM> { USING IMeshBuilder<MaterialBuilder> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG,TvM> { USING MeshBuilder<MaterialBuilder,TvG,TvM,VertexEmpty> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG> { USING IMeshBuilder<MaterialBuilder> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvG> { USING MeshBuilder<MaterialBuilder,TvG,VertexEmpty,VertexEmpty> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD IsolateColumns Void () } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:GET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:GET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:GET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:GET Tangents IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:SET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:SET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:SET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTargetColumns { METHOD:SET Tangents IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddLine ValueTuple<Int32,Int32> (VertexBuilder<TvG,TvM,TvS>, VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddPoint Int32 (VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddTriangle ValueTuple<Int32,Int32,Int32> (VertexBuilder<TvG,TvM,TvS>, VertexBuilder<TvG,TvM,TvS>, VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD TransformVertices Void (Func<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD UseVertex Int32 (VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD Validate Void () } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET Mesh MeshBuilder<TMaterial,TvG,TvM,TvS> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET Vertices IReadOnlyList<VertexBuilder<TvG,TvM,TvS>> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Indices IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Lines IReadOnlyList<ValueTuple<Int32,Int32>> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Material TMaterial } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Points IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Triangles IReadOnlyList<ValueTuple<Int32,Int32,Int32>> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL VertexType Type } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL VerticesPerPrimitive Int32 } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL AddLine ValueTuple<Int32,Int32> (IVertexBuilder, IVertexBuilder) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL AddPoint Int32 (IVertexBuilder) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL AddTriangle ValueTuple<Int32,Int32,Int32> (IVertexBuilder, IVertexBuilder, IVertexBuilder) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { USING IPrimitiveBuilder } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { USING IPrimitiveReader<TMaterial> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD AddMorphTarget MorphTargetColumns () } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD ApplyTransform Void (IGeometryTransform) } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD GetCompatibleVertexType Type () } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD GetVertex IVertexBuilder (Type, Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD GetVertex VertexBuilder<TvG,TvM,TvS> (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD GetVertex VertexBuilder<TvG,TvM,VertexEmpty> (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD IsolateColumns Void () } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET MorphTargets IReadOnlyList<MorphTargetColumns> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET TexCoords0 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET TexCoords1 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:GET Weights1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET TexCoords0 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET TexCoords1 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexBufferColumns { METHOD:SET Weights1 IList<Vector4> } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:ABSTRACT UsePrimitive IPrimitiveBuilder (TMaterial, Int32=3) } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:GET:ABSTRACT Materials IEnumerable<TMaterial> } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:GET:ABSTRACT Name String } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:GET:ABSTRACT Primitives IReadOnlyCollection<IPrimitiveReader<TMaterial>> } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:SET:ABSTRACT Name String } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveBuilder { METHOD:ABSTRACT AddLine ValueTuple<Int32,Int32> (IVertexBuilder, IVertexBuilder) } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveBuilder { METHOD:ABSTRACT AddPoint Int32 (IVertexBuilder) } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveBuilder { METHOD:ABSTRACT AddTriangle ValueTuple<Int32,Int32,Int32> (IVertexBuilder, IVertexBuilder, IVertexBuilder) } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveBuilder { METHOD:GET:ABSTRACT VertexType Type } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Indices IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Lines IReadOnlyList<ValueTuple<Int32,Int32>> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Material TMaterial } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Points IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Triangles IReadOnlyList<ValueTuple<Int32,Int32,Int32>> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT Vertices IReadOnlyList<IVertexBuilder> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveReader<TMaterial> { METHOD:GET:ABSTRACT VerticesPerPrimitive Int32 } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT ConvertTo VertexBuilder<TvPP,TvMM,TvSS> () } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT GetGeometry IVertexGeometry () } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT GetMaterial IVertexMaterial () } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT GetSkinning IVertexSkinning () } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT SetGeometry Void (IVertexGeometry) } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT SetMaterial Void (IVertexMaterial) } }
+NS SharpGLTF.Geometry { INTERFACE IVertexBuilder { METHOD:ABSTRACT SetSkinning Void (IVertexSkinning) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { FIELD Geometry TvG } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { FIELD Material TvM } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { FIELD Skinning TvS } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD Validate Void () } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithGeometry VertexBuilder<TvG,TvM,TvS> (Vector3) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithGeometry VertexBuilder<TvG,TvM,TvS> (Vector3, Vector3) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithGeometry VertexBuilder<TvG,TvM,TvS> (Vector3, Vector3, Vector4) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithMaterial VertexBuilder<TvG,TvM,TvS> (params Vector2[]) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithMaterial VertexBuilder<TvG,TvM,TvS> (Vector4, params Vector2[]) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithMaterial VertexBuilder<TvG,TvM,TvS> (Vector4, Vector4, params Vector2[]) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD WithSkinning VertexBuilder<TvG,TvM,TvS> (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, SparseWeight8) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, TvM) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, TvM, params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, TvM, SparseWeight8) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, TvM, TvS) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG, TvS) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:GET Position Vector3 } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:SET Position Vector3 } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:STATIC Create VertexBuilder<TvG,TvM,TvS> (Vector3) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:STATIC Create VertexBuilder<TvG,TvM,TvS> (Vector3, Vector3) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:STATIC Create VertexBuilder<TvG,TvM,TvS> (Vector3, Vector3, Vector4) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:STATIC CreateCompatibleMesh MeshBuilder<TMaterial,TvG,TvM,TvS> (String=null) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:STATIC CreateCompatibleMesh MeshBuilder<TvG,TvM,TvS> (String=null) } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:VIRTUAL ConvertTo VertexBuilder<TvPP,TvMM,TvSS> () } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { USING IVertexBuilder } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { METHOD:CONSTRUCTOR (String) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { METHOD:CONSTRUCTOR (String, EncodingType, Boolean) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { METHOD:GET Encoding EncodingType } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { METHOD:GET Name String } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { METHOD:GET Normalized Boolean } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexAttributeAttribute { USING Attribute } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { METHOD:CONSTRUCTOR (Object, IntPtr) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { METHOD:VIRTUAL BeginInvoke IAsyncResult (TvG, AsyncCallback, Object) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { METHOD:VIRTUAL EndInvoke Nullable<TvG> (IAsyncResult) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { METHOD:VIRTUAL Invoke Nullable<TvG> (TvG) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { USING Delegate } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { USING ICloneable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { USING ISerializable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexGeometryPreprocessor<TvG> { USING MulticastDelegate } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { METHOD:CONSTRUCTOR (Object, IntPtr) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { METHOD:VIRTUAL BeginInvoke IAsyncResult (TvM, AsyncCallback, Object) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { METHOD:VIRTUAL EndInvoke Nullable<TvM> (IAsyncResult) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { METHOD:VIRTUAL Invoke Nullable<TvM> (TvM) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { USING Delegate } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { USING ICloneable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { USING ISerializable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexMaterialPreprocessor<TvM> { USING MulticastDelegate } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD Append Void (VertexGeometryPreprocessor<TvG>) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD Append Void (VertexMaterialPreprocessor<TvM>) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD Append Void (VertexSkinningPreprocessor<TvS>) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD Clear Void () } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD PreprocessVertex Boolean (ref VertexBuilder`3) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD SetDebugPreprocessors Void () } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD SetSanitizerPreprocessors Void () } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexPreprocessor<TvG,TvM,TvS> { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { METHOD:CONSTRUCTOR (Object, IntPtr) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { METHOD:VIRTUAL BeginInvoke IAsyncResult (TvS, AsyncCallback, Object) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { METHOD:VIRTUAL EndInvoke Nullable<TvS> (IAsyncResult) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { METHOD:VIRTUAL Invoke Nullable<TvS> (TvS) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { USING Delegate } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { USING ICloneable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { USING ISerializable } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS:SEALED VertexSkinningPreprocessor<TvS> { USING MulticastDelegate } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT ApplyTransform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT SetNormal Void (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT SetPosition Void (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT SetTangent Void (Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT TryGetNormal Boolean (out Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT TryGetTangent Boolean (out Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexGeometry { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:ABSTRACT GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:ABSTRACT GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:ABSTRACT SetColor Void (Int32, Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:ABSTRACT SetTexCoord Void (Int32, Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:GET:ABSTRACT MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexMaterial { METHOD:GET:ABSTRACT MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT GetJointBinding ValueTuple<Int32,Single> (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT JointsHigh Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT JointsLow Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT Weightshigh Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT WeightsLow Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { FIELD Color Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:CONSTRUCTOR (Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { FIELD Color Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { FIELD TexCoord Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:CONSTRUCTOR (Vector4, Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture1 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { FIELD Color Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { FIELD TexCoord0 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { FIELD TexCoord1 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:CONSTRUCTOR (Vector4, Vector2, Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1Texture2 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { FIELD Color0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { FIELD Color1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:CONSTRUCTOR (Vector4, Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { FIELD Color0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { FIELD Color1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { FIELD TexCoord0 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { FIELD TexCoord1 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:CONSTRUCTOR (Vector4, Vector4, Vector2, Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor2Texture2 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD:VIRTUAL GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexEmpty { USING IVertexSkinning } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { FIELD Joints Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { FIELD Weights Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD InPlaceSort Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:VIRTUAL GetJointBinding ValueTuple<Int32,Single> (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:VIRTUAL GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:VIRTUAL SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { USING IVertexSkinning } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { FIELD Joints0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { FIELD Joints1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { FIELD Weights0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { FIELD Weights1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:CONSTRUCTOR (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:CONSTRUCTOR (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:VIRTUAL GetJointBinding ValueTuple<Int32,Single> (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:VIRTUAL GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:VIRTUAL SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { USING IVertexSkinning } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { FIELD Joints Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { FIELD Weights Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD InPlaceSort Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:VIRTUAL GetJointBinding ValueTuple<Int32,Single> (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:VIRTUAL GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:VIRTUAL SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { USING IVertexSkinning } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { FIELD Joints0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { FIELD Joints1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { FIELD Weights0 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { FIELD Weights1 Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD SetWeights Void (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:CONSTRUCTOR (in SparseWeight8) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:CONSTRUCTOR (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:GET SparseWeights SparseWeight8 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:VIRTUAL GetJointBinding ValueTuple<Int32,Single> (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:VIRTUAL GetWeights SparseWeight8 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:VIRTUAL SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { USING IVertexSkinning } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { FIELD Position Vector3 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:CONSTRUCTOR (IVertexGeometry) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:CONSTRUCTOR (Single, Single, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:CONSTRUCTOR (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL ApplyTransform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL TryGetNormal Boolean (out Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL TryGetTangent Boolean (out Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { USING IVertexGeometry } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { FIELD Normal Vector3 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { FIELD Position Vector3 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:CONSTRUCTOR (IVertexGeometry) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:CONSTRUCTOR (Single, Single, Single, Single, Single, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:CONSTRUCTOR (Vector3, Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL ApplyTransform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL TryGetNormal Boolean (out Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL TryGetTangent Boolean (out Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { USING IVertexGeometry } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { FIELD Normal Vector3 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { FIELD Position Vector3 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { FIELD Tangent Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:CONSTRUCTOR (IVertexGeometry) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:CONSTRUCTOR (Vector3, Vector3, Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL ApplyTransform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL TryGetNormal Boolean (out Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL TryGetTangent Boolean (out Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { USING IVertexGeometry } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { FIELD TexCoord Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:CONSTRUCTOR (Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { USING IVertexMaterial } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { FIELD TexCoord0 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { FIELD TexCoord1 Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:CONSTRUCTOR (IVertexMaterial) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:CONSTRUCTOR (Vector2, Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:GET:VIRTUAL MaxColors Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:GET:VIRTUAL MaxTextCoords Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:VIRTUAL GetColor Vector4 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:VIRTUAL GetTexCoord Vector2 (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture2 { USING IVertexMaterial } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD RemoveTexture Void () } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD SetDefaultParameter Void () } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD UseTexture TextureBuilder () } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:GET Key String } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:GET Parameter Vector4 } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:GET Texture TextureBuilder } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:GET:STATIC ContentComparer IEqualityComparer<ChannelBuilder> } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:SET Parameter Vector4 } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:STATIC AreEqual Boolean (ChannelBuilder, ChannelBuilder) } }
+NS SharpGLTF.Materials { CLASS ChannelBuilder { METHOD:STATIC GetContentHashCode Int32 (ChannelBuilder) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { FIELD:CONST SHADERPBRMETALLICROUGHNESS String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { FIELD:CONST SHADERPBRSPECULARGLOSSINESS String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { FIELD:CONST SHADERUNLIT String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD GetChannel ChannelBuilder (KnownChannels) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD GetChannel ChannelBuilder (String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD UseChannel ChannelBuilder (KnownChannels) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD UseChannel ChannelBuilder (String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithAlpha MaterialBuilder (AlphaMode=OPAQUE, Single=0,5) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithChannelImage MaterialBuilder (KnownChannels, String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithChannelImage MaterialBuilder (String, String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithChannelParam MaterialBuilder (KnownChannels, Vector4) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithChannelParam MaterialBuilder (String, Vector4) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithDoubleSide MaterialBuilder (Boolean) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithEmissive MaterialBuilder (String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithEmissive MaterialBuilder (String, Vector3) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithEmissive MaterialBuilder (Vector3) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithFallback MaterialBuilder (MaterialBuilder) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithMetallicRoughnessShader MaterialBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithNormal MaterialBuilder (String, Single=1) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithOcclusion MaterialBuilder (String, Single=1) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithShader MaterialBuilder (String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithSpecularGlossinessShader MaterialBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithUnlitShader MaterialBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET AlphaCutoff Single } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET AlphaMode AlphaMode } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET Channels IReadOnlyCollection<ChannelBuilder> } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET CompatibilityFallback MaterialBuilder } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET DoubleSided Boolean } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET Name String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET ShaderStyle String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:GET:STATIC ContentComparer IEqualityComparer<MaterialBuilder> } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET AlphaCutoff Single } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET AlphaMode AlphaMode } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET CompatibilityFallback MaterialBuilder } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET DoubleSided Boolean } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET Name String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:SET ShaderStyle String } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:STATIC AreEqual Boolean (MaterialBuilder, MaterialBuilder) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:STATIC CreateDefault MaterialBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD:STATIC GetContentHashCode Int32 (MaterialBuilder) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithCoordinateSet TextureBuilder (Int32) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithFallbackImage TextureBuilder (ArraySegment<Byte>) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithFallbackImage TextureBuilder (String) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithImage TextureBuilder (ArraySegment<Byte>) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithImage TextureBuilder (String) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithPrimaryImage TextureBuilder (ArraySegment<Byte>) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithPrimaryImage TextureBuilder (String) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithSampler TextureBuilder (TextureWrapMode, TextureWrapMode, TextureMipMapFilter=DEFAULT, TextureInterpolationFilter=DEFAULT) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithTransform TextureBuilder (Single, Single, Single=1, Single=1, Single=0, Nullable<Int32>=null) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithTransform TextureBuilder (Vector2, Vector2, Single=0, Nullable<Int32>=null) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET CoordinateSet Int32 } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET FallbackImageContent ArraySegment<Byte> } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET MagFilter TextureInterpolationFilter } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET MinFilter TextureMipMapFilter } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET PrimaryImageContent ArraySegment<Byte> } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET Transform TextureTransformBuilder } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET WrapS TextureWrapMode } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET WrapT TextureWrapMode } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET:STATIC ContentComparer IEqualityComparer<TextureBuilder> } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET CoordinateSet Int32 } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET FallbackImageContent ArraySegment<Byte> } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET MagFilter TextureInterpolationFilter } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET MinFilter TextureMipMapFilter } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET PrimaryImageContent ArraySegment<Byte> } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET WrapS TextureWrapMode } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET WrapT TextureWrapMode } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:STATIC AreEqual Boolean (TextureBuilder, TextureBuilder) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:STATIC GetContentHashCode Int32 (TextureBuilder) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:STATIC IsImage Boolean (ArraySegment<Byte>, String) } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:GET CoordinateSetOverride Nullable<Int32> } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:GET Offset Vector2 } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:GET Rotation Single } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:GET Scale Vector2 } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:SET CoordinateSetOverride Nullable<Int32> } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:SET Offset Vector2 } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:SET Rotation Single } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:SET Scale Vector2 } }
+NS SharpGLTF.Materials { CLASS TextureTransformBuilder { METHOD:STATIC AreEqual Boolean (TextureTransformBuilder, TextureTransformBuilder) } }
+NS SharpGLTF.Materials { ENUM AlphaMode { BLEND=2 } }
+NS SharpGLTF.Materials { ENUM AlphaMode { MASK=1 } }
+NS SharpGLTF.Materials { ENUM AlphaMode { OPAQUE=0 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { BaseColor=3 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { Diffuse=5 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { Emissive=2 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { MetallicRoughness=4 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { Normal=0 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { Occlusion=1 } }
+NS SharpGLTF.Materials { ENUM KnownChannels { SpecularGlossiness=6 } }
+NS SharpGLTF.Scenes { CLASS InstanceBuilder { METHOD:GET Content ContentTransformer } }
+NS SharpGLTF.Scenes { CLASS InstanceBuilder { METHOD:GET Name String } }
+NS SharpGLTF.Scenes { CLASS InstanceBuilder { METHOD:SET Content ContentTransformer } }
+NS SharpGLTF.Scenes { CLASS InstanceBuilder { METHOD:SET Name String } }
+NS SharpGLTF.Scenes { CLASS InstanceBuilder { USING IOperator<Scene> } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD CreateNode NodeBuilder (String=null) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD GetLocalTransform AffineTransform (String, Single) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD GetWorldMatrix Matrix4x4 (String, Single) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD SetRotationTrack Void (String, ICurveSampler<Quaternion>) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD SetScaleTrack Void (String, ICurveSampler<Vector3>) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD SetTranslationTrack Void (String, ICurveSampler<Vector3>) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseRotation AnimatableProperty<Quaternion> () } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseRotation CurveBuilder<Quaternion> (String) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseScale AnimatableProperty<Vector3> () } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseScale CurveBuilder<Vector3> (String) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseTranslation AnimatableProperty<Vector3> () } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD UseTranslation CurveBuilder<Vector3> (String) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD WithLocalRotation NodeBuilder (Quaternion) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD WithLocalScale NodeBuilder (Vector3) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD WithLocalTranslation NodeBuilder (Vector3) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:CONSTRUCTOR (String) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET HasAnimations Boolean } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET LocalMatrix Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET LocalTransform AffineTransform } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Name String } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Parent NodeBuilder } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Root NodeBuilder } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Rotation AnimatableProperty<Quaternion> } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Scale AnimatableProperty<Vector3> } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET Translation AnimatableProperty<Vector3> } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET VisualChildren IReadOnlyList<NodeBuilder> } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:GET WorldMatrix Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:SET LocalMatrix Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:SET LocalTransform AffineTransform } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:SET Name String } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:SET WorldMatrix Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:STATIC Flatten IEnumerable<NodeBuilder> (NodeBuilder) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:STATIC IsValidArmature Boolean (IEnumerable<NodeBuilder>) } }
+NS SharpGLTF.Scenes { CLASS NodeBuilder { METHOD:STATIC Rename Void (IEnumerable<NodeBuilder>, String) } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { METHOD:CONSTRUCTOR (IMeshBuilder<MaterialBuilder>, NodeBuilder) } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { METHOD:CONSTRUCTOR (Object, NodeBuilder) } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { METHOD:GET Transform NodeBuilder } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { METHOD:SET Transform NodeBuilder } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { METHOD:VIRTUAL GetArmatureAsset NodeBuilder () } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { USING ContentTransformer } }
+NS SharpGLTF.Scenes { CLASS NodeTransformer { USING IOperator<Scene> } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddMesh InstanceBuilder (IMeshBuilder<MaterialBuilder>, Matrix4x4) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddMesh InstanceBuilder (IMeshBuilder<MaterialBuilder>, NodeBuilder) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddOrthographicCamera InstanceBuilder (NodeBuilder, Single, Single, Single, Single) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddPerspectiveCamera InstanceBuilder (NodeBuilder, Nullable<Single>, Single, Single, Single=∞) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddSkinnedMesh InstanceBuilder (IMeshBuilder<MaterialBuilder>, Matrix4x4, params NodeBuilder[]) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD AddSkinnedMesh InstanceBuilder (IMeshBuilder<MaterialBuilder>, params ValueTuple[]<NodeBuilder,Matrix4x4>) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD RenameAllNodes Void (String) } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD ToSchema2 ModelRoot () } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Scenes { CLASS SceneBuilder { METHOD:GET Instances IReadOnlyList<InstanceBuilder> } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { METHOD GetJointBindings ValueTuple[]<NodeBuilder,Matrix4x4> () } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { METHOD GetWorldTransformer IGeometryTransform (String, Single) } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { METHOD:CONSTRUCTOR (IMeshBuilder<MaterialBuilder>, Matrix4x4, NodeBuilder[]) } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { METHOD:CONSTRUCTOR (IMeshBuilder<MaterialBuilder>, ValueTuple[]<NodeBuilder,Matrix4x4>) } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { METHOD:VIRTUAL GetArmatureAsset NodeBuilder () } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { USING ContentTransformer } }
+NS SharpGLTF.Scenes { CLASS SkinTransformer { USING IOperator<Scene> } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { METHOD:CONSTRUCTOR (IMeshBuilder<MaterialBuilder>, Matrix4x4) } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { METHOD:CONSTRUCTOR (Object, Matrix4x4) } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { METHOD:GET WorldTransform Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { METHOD:SET WorldTransform Matrix4x4 } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { METHOD:VIRTUAL GetArmatureAsset NodeBuilder () } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { USING ContentTransformer } }
+NS SharpGLTF.Scenes { CLASS StaticTransformer { USING IOperator<Scene> } }
+NS SharpGLTF.Scenes { CLASS:ABSTRACT ContentTransformer { METHOD:ABSTRACT GetArmatureAsset NodeBuilder () } }
+NS SharpGLTF.Scenes { CLASS:ABSTRACT ContentTransformer { METHOD:CONSTRUCTOR (IMeshBuilder<MaterialBuilder>) } }
+NS SharpGLTF.Scenes { CLASS:ABSTRACT ContentTransformer { METHOD:CONSTRUCTOR (Object) } }
+NS SharpGLTF.Scenes { CLASS:ABSTRACT ContentTransformer { METHOD:GET Content Object } }
+NS SharpGLTF.Scenes { CLASS:ABSTRACT ContentTransformer { METHOD:VIRTUAL GetGeometryAsset IMeshBuilder<MaterialBuilder> () } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION AddMesh Void (MeshBuilder<TMaterial,TvG,TvM,TvS>, Mesh, Func<Material,TMaterial>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyChannelsTo Void (Material, MaterialBuilder, params String[]) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyChannelsTo Void (MaterialBuilder, Material, params String[]) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyTo Void (ChannelBuilder, MaterialChannel) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyTo Void (Material, MaterialBuilder) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyTo Void (MaterialBuilder, Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyTo Void (MaterialChannel, ChannelBuilder) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMaterial Material (ModelRoot, MaterialBuilder) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, Func<TMaterial,Material>, IMeshBuilder<TMaterial>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, IMeshBuilder<MaterialBuilder>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, Func<TMaterial,Material>, params IMeshBuilder[]<TMaterial>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, params IMeshBuilder[]<MaterialBuilder>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateVertexAccessor Accessor (ModelRoot, MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateLines IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,Material>> (Mesh, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateLines IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,Material>> (MeshPrimitive, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluatePoints IEnumerable<ValueTuple<IVertexBuilder,Material>> (Mesh, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluatePoints IEnumerable<ValueTuple<IVertexBuilder,Material>> (MeshPrimitive, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,IVertexBuilder,Material>> (Mesh, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,IVertexBuilder,Material>> (MeshPrimitive, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,IVertexBuilder,Material>> (Node, Animation=null, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<IVertexBuilder,IVertexBuilder,IVertexBuilder,Material>> (Scene, Animation=null, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,Material>> (Mesh, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,Material>> (MeshPrimitive, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,Material>> (Node, Animation=null, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION EvaluateTriangles IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,Material>> (Scene, Animation=null, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION FindNode Node (Node, Predicate<Node>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION FindNode Node (Scene, Predicate<Node>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetComputedNormals Dictionary<Vector3,Vector3> (Mesh) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetDiffuseColor Vector4 (Material, Vector4) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetDiffuseTexture Texture (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetLineIndices IEnumerable<ValueTuple<Int32,Int32>> (MeshPrimitive) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetPointIndices IEnumerable<Int32> (MeshPrimitive) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetPrimitiveVertexSize Int32 (PrimitiveType) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetTriangleIndices IEnumerable<ValueTuple<Int32,Int32,Int32>> (MeshPrimitive) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetVertexColumns VertexBufferColumns (MeshPrimitive, IGeometryTransform=null) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION SaveAsWavefront Void (ModelRoot, String) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION SaveAsWavefront Void (ModelRoot, String, Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToMeshBuilder IMeshBuilder<MaterialBuilder> (Mesh) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToSceneBuilder SceneBuilder (Scene) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToSchema2 AlphaMode (AlphaMode) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToStaticMeshBuilder MeshBuilder<MaterialBuilder,TvG,TvM,VertexEmpty> (Scene, Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToStaticMeshBuilder MeshBuilder<TMaterial,TvG,TvM,VertexEmpty> (Scene, Func<Material,TMaterial>, Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION ToToolkit AlphaMode (AlphaMode) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION UseAnimation Animation (ModelRoot, String) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION UseImageWithContent Image (ModelRoot, Byte[]) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION UseImageWithFile Image (ModelRoot, String) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithChannelParameter Material (Material, String, Vector4) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithChannelTexture Material (Material, String, Int32, Image) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithChannelTexture Material (Material, String, Int32, String) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithColor PunctualLight (PunctualLight, Vector3, Single=1, Single=0) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithDefault Material (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithDefault Material (Material, Vector4) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithDoubleSide Material (Material, Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithIndicesAccessor MeshPrimitive (MeshPrimitive, PrimitiveType, IReadOnlyList<Int32>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithIndicesAccessor MeshPrimitive (MeshPrimitive, PrimitiveType, MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithIndicesAutomatic MeshPrimitive (MeshPrimitive, PrimitiveType) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithLocalRotation Node (Node, Quaternion) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithLocalScale Node (Node, Vector3) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithLocalTransform Node (Node, AffineTransform) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithLocalTranslation Node (Node, Vector3) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithMaterial MeshPrimitive (MeshPrimitive, Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithMesh Node (Node, Mesh) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithOrthographicCamera Node (Node, Single, Single, Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithPBRMetallicRoughness Material (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithPBRMetallicRoughness Material (Material, Vector4, String, String=null, Single=1, Single=1) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithPBRSpecularGlossiness Material (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithPerspectiveCamera Node (Node, Nullable<Single>, Single, Single, Single=∞) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithRotationAnimation Node (Node, String, ICurveSampler<Quaternion>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithRotationAnimation Node (Node, String, IReadOnlyDictionary<Single,Quaternion>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithRotationAnimation Node (Node, String, params ValueTuple[]<Single,Quaternion>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithScaleAnimation Node (Node, String, ICurveSampler<Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithScaleAnimation Node (Node, String, IReadOnlyDictionary<Single,Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithScaleAnimation Node (Node, String, params ValueTuple[]<Single,Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSkin Node (Node, Skin) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSkinBinding Node (Node, Matrix4x4, params Node[]) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSkinBinding Node (Node, params ValueTuple[]<Node,Matrix4x4>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSkinnedMesh Node (Node, Mesh, Matrix4x4, params Node[]) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSkinnedMesh Node (Node, Mesh, params ValueTuple[]<Node,Matrix4x4>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithSpotCone PunctualLight (PunctualLight, Single, Single) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithTranslationAnimation Node (Node, String, ICurveSampler<Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithTranslationAnimation Node (Node, String, IReadOnlyDictionary<Single,Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithTranslationAnimation Node (Node, String, params ValueTuple[]<Single,Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithUnlit Material (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Single>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector2>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector4>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IEnumerable<MemoryAccessor>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<TVertex>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<ValueTuple<TvP,TvM,TvS>>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<ValueTuple<TvP,TvM>>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<VertexPosition>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<VertexPositionNormal>) } }

tests/SharpGLTF.Tests/SharpGLTF.Tests.csproj

@@ -39,6 +39,9 @@
     <None Update="Assets\API.Core.1.0.0-alpha0009.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="Assets\API.Core.1.0.0-alpha0010.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="Assets\API.Toolkit.1.0.0-alpha0005.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -54,6 +57,9 @@
     <None Update="Assets\API.Toolkit.1.0.0-alpha0009.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="Assets\API.Toolkit.1.0.0-alpha0010.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="Assets\Invalid_Json.gltf">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>