bumped version

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-alpha0008</Version>
+    <Version>1.0.0-alpha0009</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-alpha0008</Version>
+    <Version>1.0.0-alpha0009</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);
 
-            var r = _CheckBackwardsCompatibility("API.Core.1.0.0-alpha0007.txt", API);
+            var r = _CheckBackwardsCompatibility("API.Core.1.0.0-alpha0008.txt", API);
 
             Assert.IsTrue(r);
         }
@@ -92,7 +92,7 @@ namespace SharpGLTF
 
             TestContext.CurrentContext.AttachText($"API.Toolkit.{Schema2.Asset.AssemblyInformationalVersion}.txt", API);
 
-            var r = _CheckBackwardsCompatibility("API.Toolkit.1.0.0-alpha0007.txt", API);
+            var r = _CheckBackwardsCompatibility("API.Toolkit.1.0.0-alpha0008.txt", API);
 
             Assert.IsTrue(r);
         }

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

@@ -0,0 +1,761 @@
+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 { 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,Single[]>) } }
+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 FindRotationChannel IEnumerable<ValueTuple<Single,Quaternion>> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindScaleChannel IEnumerable<ValueTuple<Single,Vector3>> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindTranslationChannel IEnumerable<ValueTuple<Single,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: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:GET LogicalIndex Int32 } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Camera { METHOD:GET Type CameraType } }
+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 { METHOD:SET Type CameraType } }
+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 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 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 GetLocalTransform AffineTransform (Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetMeshWorldTransform ITransform () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetMeshWorldTransform ITransform (Animation, Single) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Node { METHOD GetWorldMatrix Matrix4x4 (Animation, Single) } }
+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 VisualScene 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 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 (KeyValuePair[]<Node,Matrix4x4>) } }
+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 GetInverseBindMatricesAccessor Accessor () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Skin { METHOD GetJoint KeyValuePair<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 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 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:CONSTRUCTOR (Matrix4x4[], Matrix4x4[], IReadOnlyList<Single>=null) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:VIRTUAL TransformNormal Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:VIRTUAL TransformPosition Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { METHOD:VIRTUAL TransformTangent Vector4 (Vector4, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { USING ITransform } }
+NS SharpGLTF.Transforms { CLASS SkinTransform { USING MorphTransform } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:CONSTRUCTOR (Matrix4x4, IReadOnlyList<Single>=null) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:VIRTUAL TransformNormal Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:VIRTUAL TransformPosition Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { METHOD:VIRTUAL TransformTangent Vector4 (Vector4, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { USING ITransform } }
+NS SharpGLTF.Transforms { CLASS StaticTransform { USING MorphTransform } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:CONSTRUCTOR (IReadOnlyList<Single>) } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:GET InverseWeight Single } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:GET MorphWeights IReadOnlyList<Single> } }
+NS SharpGLTF.Transforms { CLASS:ABSTRACT MorphTransform { METHOD:PROTECTED MorphVectors Vector3 (Vector3, Vector3[]) } }
+NS SharpGLTF.Transforms { INTERFACE ITransform { METHOD:ABSTRACT TransformNormal Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { INTERFACE ITransform { METHOD:ABSTRACT TransformPosition Vector3 (Vector3, Vector3[], ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Transforms { INTERFACE ITransform { METHOD:ABSTRACT TransformTangent Vector4 (Vector4, Vector3[], ValueTuple[]<Int32,Single>) } }
+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: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.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-alpha0008.txt

@@ -0,0 +1,448 @@
+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 StrictMode Boolean } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET Triangulator IPolygonTriangulator } }
+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 StrictMode Boolean } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvG,TvM,TvS> { METHOD:SET Triangulator IPolygonTriangulator } }
+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 MorphTarget { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:GET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:GET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:GET Tangents IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:SET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:SET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS MorphTarget { METHOD:SET Tangents IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddLine Void (VertexBuilder<TvG,TvM,TvS>, VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddPoint Void (VertexBuilder<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddPolygon Void (params VertexBuilder[]<TvG,TvM,TvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD AddTriangle Void (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 VerticesPerPrimitive Int32 } }
+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 IEnumerable<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 IEnumerable<Int32> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL Triangles IEnumerable<ValueTuple<Int32,Int32,Int32>> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:GET:VIRTUAL VertexCount Int32 } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL AddTriangle Void (VertexBuilder<TvPP,TvMM,TvSS>, VertexBuilder<TvPP,TvMM,TvSS>, VertexBuilder<TvPP,TvMM,TvSS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { METHOD:VIRTUAL GetVertex VertexBuilder<TvPP,TvMM,TvSS> (Int32) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { USING IPrimitive<TMaterial> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvG,TvM,TvS> { USING IPrimitiveBuilder } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:CONSTRUCTOR () } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:GET Normals IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:GET Positions IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:GET Tangents IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:SET Normals IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:SET Positions IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { CLASS MorphTarget { METHOD:SET Tangents IList<Vector3> } } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD AddMorphTarget MorphTarget () } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD ApplyNormals Void (IReadOnlyDictionary<Vector3,Vector3>) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD ApplyTransform Void (ITransform) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD GetVertex VertexBuilder<TvG,TvM,TvS> (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD GetVertex VertexBuilder<TvG,TvM,VertexEmpty> (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD GetVertexGeometry TvG (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD GetVertexMaterial TvM (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD GetVertexSkinning TvS (Int32) } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD IsolateNormals Void () } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD IsolatePositions Void () } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD IsolateTangents Void () } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET MorphTargets IReadOnlyList<MorphTarget> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Textures0 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Textures1 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:GET Weights1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Textures0 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Textures1 IList<Vector2> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { METHOD:SET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry { CLASS VertexColumns { 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<IPrimitive<TMaterial>> } }
+NS SharpGLTF.Geometry { INTERFACE IMeshBuilder<TMaterial> { METHOD:SET:ABSTRACT Name String } }
+NS SharpGLTF.Geometry { INTERFACE IPolygonTriangulator { METHOD:ABSTRACT Triangulate Void (Span<Int32>, ReadOnlySpan<Vector3>) } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:ABSTRACT GetVertex VertexBuilder<TvGG,TvMM,TvSS> (Int32) } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT Indices IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT Lines IEnumerable<ValueTuple<Int32,Int32>> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT Material TMaterial } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT Points IEnumerable<Int32> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT Triangles IEnumerable<ValueTuple<Int32,Int32,Int32>> } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitive<TMaterial> { METHOD:GET:ABSTRACT VertexCount Int32 } }
+NS SharpGLTF.Geometry { INTERFACE IPrimitiveBuilder { METHOD:ABSTRACT AddTriangle Void (VertexBuilder<TvGG,TvMM,TvSS>, VertexBuilder<TvGG,TvMM,TvSS>, VertexBuilder<TvGG,TvMM,TvSS>) } }
+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 ConvertTo VertexBuilder<TvPP,TvMM,TvSS> () } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD Validate Void () } }
+NS SharpGLTF.Geometry { STRUCT VertexBuilder<TvG,TvM,TvS> { METHOD:CONSTRUCTOR (TvG) } }
+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, 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 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.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 { 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 Transform Void (Matrix4x4) } }
+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 MaxTextures Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT GetJointBinding JointBinding (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT SetJointBinding Void (Int32, Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT JointBindings IEnumerable<JointBinding> } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:GET:ABSTRACT MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { FIELD Joint Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { FIELD Weight Single } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { METHOD:CONSTRUCTOR (Int32, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { METHOD:STATIC GetBindings IEnumerable<JointBinding> (IVertexSkinning) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { METHOD:VIRTUAL CompareTo Int32 (JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT JointBinding { USING IComparable<JointBinding> } }
+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 MaxTextures 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 MaxTextures 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 MaxTextures 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 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 MaxTextures 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:GET:VIRTUAL JointBindings IEnumerable<JointBinding> } }
+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 MaxTextures Int32 } }
+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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding, JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:GET:VIRTUAL JointBindings IEnumerable<JointBinding> } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:VIRTUAL GetJointBinding JointBinding (Int32) } }
+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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:CONSTRUCTOR (Int32, Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:GET:VIRTUAL JointBindings IEnumerable<JointBinding> } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x8 { METHOD:VIRTUAL GetJointBinding JointBinding (Int32) } }
+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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (JointBinding, JointBinding, JointBinding, JointBinding) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (params ValueTuple[]<Int32,Single>) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:GET:VIRTUAL JointBindings IEnumerable<JointBinding> } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:VIRTUAL GetJointBinding JointBinding (Int32) } }
+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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:CONSTRUCTOR (Int32, Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:GET:VIRTUAL JointBindings IEnumerable<JointBinding> } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:GET:VIRTUAL MaxBindings Int32 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x8 { METHOD:VIRTUAL GetJointBinding JointBinding (Int32) } }
+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 GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+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 GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+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 GetPosition Vector3 () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+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 MaxTextures 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.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:SET Parameter Vector4 } }
+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: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 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 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: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 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 { 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.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>, MeshBuilder<TMaterial,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, MeshBuilder<Material,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, MeshBuilder<MaterialBuilder,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, Func<TMaterial,Material>, params MeshBuilder[]<TMaterial,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, params MeshBuilder[]<Material,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, params MeshBuilder[]<MaterialBuilder,TvP,TvM,TvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateVertexAccessor Accessor (ModelRoot, MemoryAccessor) } }
+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 GetTriangleIndices IEnumerable<ValueTuple<Int32,Int32,Int32>> (MeshPrimitive) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION GetVertexColumns VertexColumns (MeshPrimitive) } }
+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 Triangulate IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,Material>> (Mesh) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,VertexBuilder<TvG,TvM,TvS>,Material>> (MeshPrimitive) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,Material>> (Mesh, ITransform) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,VertexBuilder<TvG,TvM,VertexEmpty>,Material>> (MeshPrimitive, ITransform) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate 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 Triangulate 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 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 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 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, 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 Node[]) } }
+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, 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<TvP>) } }
+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<VertexBuilder<TvP,TvM,TvS>>) } }