Final touches to the API.

More documentation.
Added API break monitor test.

README.md

@@ -9,73 +9,32 @@
 SharpGLTF is a NetStandard 2.0, .NET library designed to support
 [Khronos Group glTF 2.0](https://github.com/KhronosGroup/glTF) file format.
 
-The current status of the library is preview alpha, but, for some use cases it is already usable.
-
-#### Design
-
-The framework is divided in two packages:
-
-- __SharpGLTF.Core__ provides the core glTF2 schema implementation, read & write operations,
-and low level API access to let direct document manipulation.
-- __SharpGLTF.Toolkit__ provides an abstraction layer over the Core package, adding convenient
-extensions and utilities to help creating meshes, materials and scenes.
+The aim of this framework is:
 
-#### Examples
+- To be able to create, manipulate, load and save glTF2 documents.
+- To provide a safe and easy to use high level API to produce 3D assets.
 
-- [Load and save glTF and GLB files.](https://github.com/vpenades/SharpGLTF/blob/3dfe005ba7210c8327867127681a2b39aa567412/tests/SharpGLTF.Tests/Schema2/LoadAndSave/LoadSampleTests.cs#L32)
-- [Create a simple triangle.](https://github.com/vpenades/SharpGLTF/blob/3dfe005ba7210c8327867127681a2b39aa567412/tests/SharpGLTF.Tests/Schema2/Authoring/BasicSceneCreationTests.cs#L95)
-- [Create a textured triangle.](https://github.com/vpenades/SharpGLTF/blob/3dfe005ba7210c8327867127681a2b39aa567412/tests/SharpGLTF.Tests/Schema2/Authoring/BasicSceneCreationTests.cs#L139)
-
-### Features
-
-#### Source Code
-- [x] glTF 2.0 code API generated from Schema.
-- [x] Helper classes for encoding / decoding buffers
-- [x] Logical Data Access.
-- [x] Visual Tree Access.
-
-#### Read / Write
-- [x] Reading and writing of *.gltf* files.
-- [x] Reading and writing of *.glb* files.
-- [x] Reading Base64 encoded buffers.
-- [x] Support of merging buffers to write one buffer *.glb* files.
+The current status of the library is preview alpha, but, for some use cases it is already usable.
 
-#### To do:
-- [ ] Writing Base64 encoded buffers.
-- [ ] Scene Evaluation.
-- [ ] GPU Evaluation.
-- [ ] Mesh Building utilities.
-- [ ] Animation utilities.
-- [ ] Material utilities
-- [ ] Skinning utilities
-- [ ] Morphing utilities
-- [ ] [Mikktspace](https://github.com/tcoppex/ext-mikktspace) Tangent space calculation. *Help Need*
+#### Quickstart
 
-### Supported extensions
+A simple example of loading a glTF file and saving it as GLB:
 
-- [x] [KHR_materials_pbrSpecularGlossiness](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
-- [x] [KHR_materials_unlit](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
-- [x] [KHR_lights_punctual](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
-- [x] [KHR_texture_transform](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform) (WIP)
+```c#
+var model = Schema2.ModelRoot.Load("model.gltf");
+model.SaveGLB("model.glb");
+```
 
-### Unsupported extensions
+#### Design
 
-- [ ] [KHR_draco_mesh_compression](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression)
-  - Depends on [Google's Draco Project](https://github.com/google/draco) which is C++ ; *Help Needed*
+The framework is divided in two packages:
 
-- [ ] [KHR_techniques_webgl](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl)
+- __[SharpGLTF.Core](src/SharpGLTF.Core/README.md)__ provides the core glTF2 schema implementation, read & write operations,
+and low level API access to let direct document manipulation.
+- __[SharpGLTF.Toolkit](src/SharpGLTF.Toolkit/README.md)__ provides a high level layer over the Core package, adding convenient
+extensions and utilities to help creating meshes, materials and scenes.
 
-- [ ] [MSFT_texture_dds](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds)
-- [ ] [MSFT_lod](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
-  - When this extension is used, the model's visual tree needs to be abstracted, which requires an extensive API rework, or a full API layer.
-- [ ] [MSFT_packing_normalRoughnessMetallic](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_packing_normalRoughnessMetallic)
-- [ ] [MSFT_packing_occlusionRoughnessMetallic](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_packing_occlusionRoughnessMetallic)
-- [ ] [AGI_articulations](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations)
-- [ ] [AGI_stk_metadata](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_stk_metadata)
-- [ ] [EXT_lights_image_based](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_lights_image_based)
-- [ ] [EXT_texture_webp](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp)
-- [ ] [ADOBE_materials_thin_transparency](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/ADOBE_materials_thin_transparency)
+#### Appendix
 
-#### Alternative glTF2 c# libraries
 - [Khronos Group glTF-CSharp-Loader](https://github.com/KhronosGroup/glTF-CSharp-Loader)
 - [Khronos Group UnityGLTF](https://github.com/KhronosGroup/UnityGLTF)

src/SharpGLTF.Core/Memory/README.md

@@ -1,7 +1,30 @@
-### Byte Array Accessors
+### Memory namespace
  
- Most data within glTF is stored in binary buffers. These buffers store both integer and floating point values.
- 
- In order to save space, buffer data can be encoded in different ways.
- 
- The helper classes in this namespace simplify the process of reading and writing encoded data to buffers.
+glTF2 stores array structures as encoded byte buffers that are not easy to handle directly.
+
+Data is accessed by `Accessors` pointing to `BufferViews` which point to `Buffers`.
+
+`Buffers` store raw Byte arrays, meanwhile `BufferViews` can be seen as slices over the
+original byte array stored in a `Buffer`
+
+This is equivalent in C# to `Byte[]` and `ArraySegment<Byte>` , a lot of the low level
+API exploits this by using this analogy of reusing low level buffers.
+
+Byte buffers is the lowest storage level of glTF, in order to expose the actual data, the
+byte buffers need to be decoded into structured data. The information required to decode
+the buffers is usually found in `Accessors`.
+
+But the actual encoding and decoding, can be achieved using these wrappers found in the
+`SharpGLTF.Memory` namespace:
+
+- `IntegerArray`
+- `ScalarArray`
+- `Vector2Array`
+- `Vector3Array`
+- `Vector4Array`
+- `QuaternionArray`
+- `Matrix4x4Array`
+- `MultiArray`
+- `SparseArray`
+
+You can use any of these structures to wrap any byte array and expose it as the given type.

src/SharpGLTF.Core/README.md

@@ -1,39 +1,49 @@
-
-#### Development
+# SharpGLTF Core
 
-The bulk of the code is generated from the schema using the SharpGLTF.CodeGen tools.
 
-All generated classes are declared by default as non public, and its fields private.
-The public API functionality is provided with hand coded partial classes.
+#### Namespaces
 
-Since this is a work in progress, not all the features might be publicly available yet.
+##### Namespace Schema2
 
-Internally, the ModelRoot object store almost all the model elements in plain lists,
-and cross referencing is done by integer indices. The public API implentation tries
-to simplify model access by resolving the references and offering a more C# friendly
-API.
+This namespace contains the collection of classes, structures and enumerations that
+represent the bulk of the API to access directly to glTF2 documents.
 
-#### Examples
+It also contains the main entry point Object that represents a glTF2 model: `ModelRoot`
 
-Many examples can be found in the Tests project, but in essence, loading a model
-is as easy as this:
+[Documentation](Schema2/README.md)
 
-```c#
-var model = Schema2.ModelRoot.Load("model.gltf");
-```
+##### Namespace IO
+
+This namespace contains the helper classes to support JSon serialization.
+
+##### Namespace Memory
+
+glTF2 stores array structures as encoded byte buffers that are not easy to handle directly.
+
+[Documentation](Memory/README.md)
+
+#### Extensions
+
+- [x] [KHR_materials_pbrSpecularGlossiness](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
+- [x] [KHR_materials_unlit](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
+- [x] [KHR_lights_punctual](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
+- [x] [KHR_texture_transform](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform) (WIP)
+- [ ] [KHR_draco_mesh_compression](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression)
+  - Depends on [Google's Draco Project](https://github.com/google/draco) which is C++ ; *Help Needed*
+
+- [ ] [KHR_techniques_webgl](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl)
+
+- [ ] [MSFT_texture_dds](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds)
+- [ ] [MSFT_lod](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
+  - When this extension is used, the model's visual tree needs to be abstracted, which requires an extensive API rework, or a full API layer.
+- [ ] [MSFT_packing_normalRoughnessMetallic](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_packing_normalRoughnessMetallic)
+- [ ] [MSFT_packing_occlusionRoughnessMetallic](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_packing_occlusionRoughnessMetallic)
+- [ ] [AGI_articulations](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations)
+- [ ] [AGI_stk_metadata](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_stk_metadata)
+- [ ] [EXT_lights_image_based](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_lights_image_based)
+- [ ] [EXT_texture_webp](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp)
+- [ ] [ADOBE_materials_thin_transparency](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/ADOBE_materials_thin_transparency)
 
-Loading a gltf and saving it as glb:
-```c#
-var model = Schema2.ModelRoot.Load("model.gltf");
-model.MergeBuffers(); // ensure there's only one buffer, which is required by GLB
-model.SaveGLB("model.glb");
-```
 
-Creating a new gltf model:
-```c#
-var model = ModelRoot.CreateModel();
-var scene = model.UseScene("Default Scene");
-var node = scene.CreateNode("Node1");
-```
 
 

src/SharpGLTF.Core/Schema2/README.md

@@ -0,0 +1,47 @@
+# Schema2 namespace
+
+This namespace contains the collection of classes, structures and enumerations that
+represent the bulk of the API to access directly to glTF2 documents.
+
+Part of the code has been generated directly from the glTF2 schema using
+[SharpGLTF.CodeGen tool](../../build/SharpGLTF.CodeGen).
+
+Not all the objects of glTF2 are exposed directly in the public API, some remain private and
+can be accessed indirectly with helper classes, for example, materials use this approach.
+
+The main object that represent a glTF document in memory is `ModelRoot`. Internally, it stores
+almost all the model elements in plain lists, and cross referencing is done by integer indices.
+The public API implentation tries to simplify document access by resolving the references and
+offering a more C# friendly API.
+
+There's two ways of traverse a glTF document: you can directly access every individual element
+using the `ModelRoot.Logical*` collections, which gives you direct access to almost all
+the individual building blocks of the document.
+
+But if you want to traverse the document as a visual graph, you start with `ModelRoot.DefaultScene`
+and from there you navigate throught the different properties and collections.
+
+`ModelRoot` also contains the methods to create, load and save a glTF document:
+
+Creating a new glTF document:
+```c#
+var model = ModelRoot.CreateModel();
+var scene = model.UseScene("Default Scene");
+var node = scene.CreateNode("Node1");
+```
+
+Loading a glTF document:
+```c#
+var model = Schema2.ModelRoot.Load("model.gltf");
+```
+
+Loading a gltf and saving it as glb:
+```c#
+var model = Schema2.ModelRoot.Load("model.gltf");
+model.SaveGLB("model.glb");
+```
+
+Notice that GLB format has a huge restriction over glTF format, which is the requirement
+to have just one binary buffer file. SharpGLTF detects this case, and if the glTF model
+has multiple buffers, under the hood it clones the whole document, and adjusts the internal
+buffers so there's always one buffer.

src/SharpGLTF.Core/Schema2/gltf.Asset.cs

@@ -15,11 +15,9 @@ namespace SharpGLTF.Schema2
 
         internal static Asset CreateDefault(string copyright)
         {
-            var av = typeof(Asset).Assembly.GetCustomAttributes(true)
-                .OfType<System.Reflection.AssemblyInformationalVersionAttribute>()
-                .FirstOrDefault();
+            var av = AssemblyInformationalVersion;
 
-            var generator = av == null ? "SharpGLTF" : "SharpGLTF " + av.InformationalVersion;
+            var generator = string.IsNullOrWhiteSpace(av) ? "SharpGLTF" : "SharpGLTF " + av;
 
             return new Asset()
             {
@@ -34,6 +32,18 @@ namespace SharpGLTF.Schema2
 
         #region properties
 
+        public static string AssemblyInformationalVersion
+        {
+            get
+            {
+                var av = typeof(Asset).Assembly.GetCustomAttributes(true)
+                .OfType<System.Reflection.AssemblyInformationalVersionAttribute>()
+                .FirstOrDefault();
+
+                return av?.InformationalVersion ?? string.Empty;
+            }
+        }
+
         private static readonly Version ZEROVERSION = new Version(0, 0);
         private static readonly Version MINVERSION = new Version(2, 0);
         private static readonly Version MAXVERSION = new Version(2, 0);

src/SharpGLTF.Toolkit/Collections/VertexList.cs

@@ -5,7 +5,7 @@ using System.Text;
 
 namespace SharpGLTF.Collections
 {
-    public class VertexList<T> : IReadOnlyList<T>
+    class VertexList<T> : IReadOnlyList<T>
         where T : struct
     {
         #region data

src/SharpGLTF.Toolkit/README.md

@@ -0,0 +1,18 @@
+# SharpGLTF Toolkit
+
+#### Features
+
+- [x] Scene Evaluation.
+- [ ] GPU Evaluation.
+- [x] Mesh Building utilities.
+- [x] Animation utilities.
+- [x] Material utilities
+- [x] Skinning utilities
+- [ ] Morphing utilities
+- [ ] [Mikktspace](https://github.com/tcoppex/ext-mikktspace) Tangent space calculation. *Help Need*
+
+#### Namespaces
+
+[Geometry](Geometry/readme.md)
+
+[Materials](Materials/readme.md)

tests/SharpGLTF.Tests/AssemblyAPITests.cs

@@ -46,7 +46,7 @@ namespace SharpGLTF
             }
         }
 
-        [Test]
+        [Test(Description = "proof of concept to dump the whole public API of an assembly")]
         public void DumpTestAPI()
         {
             TestContext.CurrentContext.AttachShowDirLink();
@@ -64,7 +64,7 @@ namespace SharpGLTF
         }
 
 
-        [Test]
+        [Test(Description ="Checks if we have introduced a breaking change between the current and previous API")]
         public void DumpCoreAPI()
         {
             TestContext.CurrentContext.AttachShowDirLink();
@@ -73,15 +73,14 @@ namespace SharpGLTF
 
             var API = DumpAssemblyAPI.GetAssemblySignature(assembly).OrderBy(item => item).ToArray();
 
-            TestContext.CurrentContext.AttachText("CoreAPI.txt", API);
+            TestContext.CurrentContext.AttachText($"API.Core.{Schema2.Asset.AssemblyInformationalVersion}.txt", API);
 
-            foreach(var l in API)
-            {
-                TestContext.WriteLine(l);
-            }
+            var r = _CheckBackwardsCompatibility("API.Core.1.0.0-alpha0005.txt", API);
+
+            Assert.IsTrue(r);
         }
 
-        [Test]
+        [Test(Description = "Checks if we have introduced a breaking change between the current and previous API")]
         public void DumpToolkitAPI()
         {
             TestContext.CurrentContext.AttachShowDirLink();
@@ -90,12 +89,31 @@ namespace SharpGLTF
 
             var API = DumpAssemblyAPI.GetAssemblySignature(assembly).OrderBy(item => item).ToArray();
 
-            TestContext.CurrentContext.AttachText("ToolkitAPI.txt", API);
+            TestContext.CurrentContext.AttachText($"API.Toolkit.{Schema2.Asset.AssemblyInformationalVersion}.txt", API);
 
-            foreach (var l in API)
+            var r = _CheckBackwardsCompatibility("API.Toolkit.1.0.0-alpha0005.txt", API);
+
+            Assert.IsTrue(r);
+        }
+
+        private static bool _CheckBackwardsCompatibility(string referenceAPIFile, string[] newLines)
+        {
+            referenceAPIFile = System.IO.Path.Combine(TestContext.CurrentContext.WorkDirectory, "Assets", referenceAPIFile);
+
+            var refLines = System.IO.File.ReadAllLines(referenceAPIFile);
+
+            bool failed = false;
+
+            foreach(var l in refLines)
             {
-                TestContext.WriteLine(l);
+                if (!newLines.Contains(l))
+                {
+                    TestContext.WriteLine($"Missing:  {l}");
+                    failed = true;
+                }
             }
+
+            return !failed;
         }
     }
 }

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

@@ -0,0 +1,696 @@
+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 ModelException { METHOD ApplyFix Void () } }
+NS SharpGLTF.IO { CLASS ModelException { METHOD:GET FixDescription String } }
+NS SharpGLTF.IO { CLASS ModelException { METHOD:GET HasFix Boolean } }
+NS SharpGLTF.IO { CLASS ModelException { USING Exception } }
+NS SharpGLTF.IO { CLASS ModelException { USING ISerializable } }
+NS SharpGLTF.IO { CLASS UnsupportedExtensionException { USING Exception } }
+NS SharpGLTF.IO { CLASS UnsupportedExtensionException { USING ISerializable } }
+NS SharpGLTF.IO { CLASS UnsupportedExtensionException { USING ModelException } }
+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 AsIntegerArray IntegerArray () } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD AsMatrix4x4Array Matrix4x4Array () } }
+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 Fill Void (IReadOnlyList<Int32>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Matrix4x4>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Quaternion>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Single>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<UInt32>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Vector2>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Vector3>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD Fill Void (IReadOnlyList<Vector4>) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD SetIndexDataSource Void (ArraySegment<Byte>, Int32, Int32) } }
+NS SharpGLTF.Memory { CLASS:SEALED MemoryAccessor { METHOD SetVertexDataSource Void (ArraySegment<Byte>, Int32, Int32, Int32) } }
+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 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 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: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 ByteLength Int32 } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:GET IsValidIndexer Boolean } }
+NS SharpGLTF.Memory { STRUCT MemoryAccessInfo { METHOD:GET IsValidVertexAttribute Boolean } }
+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: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: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: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: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: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: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 AsIndicesArray IntegerArray () } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Accessor { METHOD AsMatrix4x4Array Matrix4x4Array () } }
+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 IReadOnlyDictionary<Single,Quaternion> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindScaleChannel IReadOnlyDictionary<Single,Vector3> (Node) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Animation { METHOD FindTranslationChannel IReadOnlyDictionary<Single,Vector3> (Node) } }
+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 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 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 UseScene Scene (Int32) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseScene Scene (String) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseTexture Texture (Image, TextureSampler) } }
+NS SharpGLTF.Schema2 { CLASS:SEALED ModelRoot { METHOD UseTextureSampler TextureSampler (TextureMipMapFilter, TextureInterpolationFilter, TextureWrapMode, TextureWrapMode) } }
+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:GET IsSkinJoint 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 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) } }
+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 (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 IsMatch Boolean (Node, KeyValuePair[]<Node,Matrix4x4>) } }
+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 { METHOD:STATIC FindSkinsUsingJoint IEnumerable<Skin> (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:GET Image Image } }
+NS SharpGLTF.Schema2 { CLASS:SEALED Texture { METHOD:GET LogicalIndex Int32 } }
+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) } }
+NS SharpGLTF.Schema2 { INTERFACE IVisualNodeContainer { METHOD:GET:ABSTRACT VisualChildren IEnumerable<Node> } }
+NS SharpGLTF.Schema2 { STRUCT MaterialChannel { METHOD SetTexture Void (Int32, Image, TextureMipMapFilter=DEFAULT, TextureInterpolationFilter=DEFAULT, TextureWrapMode=REPEAT, TextureWrapMode=REPEAT) } }
+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 { 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 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) } }

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

@@ -0,0 +1,275 @@
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddMesh Void (MeshBuilder<TMaterial,TvP,TvM,JvS>, Matrix4x4) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD GetIndices IReadOnlyList<Int32> (TMaterial) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD GetTriangles IEnumerable<ValueTuple<Int32,Int32,Int32>> (TMaterial) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD UsePrimitive PrimitiveBuilder<TMaterial,TvP,TvM,JvS> (TMaterial) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD Validate Void () } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Name String } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Primitives IReadOnlyCollection<PrimitiveBuilder<TMaterial,TvP,TvM,JvS>> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET StrictMode Boolean } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:SET Name String } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TMaterial,TvP,TvM,JvS> { METHOD:SET StrictMode Boolean } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP,TvM,JvS> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP,TvM,JvS> { USING MeshBuilder<MaterialBuilder,TvP,TvM,JvS> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP,TvM> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP,TvM> { USING MeshBuilder<MaterialBuilder,TvP,TvM,VertexEmpty> } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP> { METHOD:CONSTRUCTOR (String=null) } }
+NS SharpGLTF.Geometry { CLASS MeshBuilder<TvP> { USING MeshBuilder<MaterialBuilder,TvP,VertexEmpty,VertexEmpty> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddPolygon Void (params TvP[]) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddPolygon Void (params ValueTuple[]<TvP,JvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddPolygon Void (params ValueTuple[]<TvP,TvM,JvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddPolygon Void (params ValueTuple[]<TvP,TvM>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddPrimitive Void (PrimitiveBuilder<TMaterial,TvP,TvM,JvS>, Matrix4x4) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddTriangle Void (TvP, TvP, TvP) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddTriangle Void (ValueTuple<TvP,JvS>, ValueTuple<TvP,JvS>, ValueTuple<TvP,JvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddTriangle Void (ValueTuple<TvP,TvM,JvS>, ValueTuple<TvP,TvM,JvS>, ValueTuple<TvP,TvM,JvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD AddTriangle Void (ValueTuple<TvP,TvM>, ValueTuple<TvP,TvM>, ValueTuple<TvP,TvM>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD UseVertex Int32 (ValueTuple<TvP,TvM,JvS>) } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD Validate Void () } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Indices IReadOnlyList<Int32> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Material TMaterial } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Mesh MeshBuilder<TMaterial,TvP,TvM,JvS> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Triangles IEnumerable<ValueTuple<Int32,Int32,Int32>> } }
+NS SharpGLTF.Geometry { CLASS PrimitiveBuilder<TMaterial,TvP,TvM,JvS> { METHOD:GET Vertices IReadOnlyList<ValueTuple<TvP,TvM,JvS>> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD GetJointsFragment JvS (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD GetMaterialFragment TvM (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD GetPositionFragment TvP (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD SetNormals Void (IReadOnlyDictionary<Vector3,Vector3>) } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:CONSTRUCTOR () } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Textures0 IList<Vector2> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Textures1 IList<Vector2> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:GET Weights1 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Colors0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Colors1 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Joints0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Joints1 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Normals IList<Vector3> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Positions IList<Vector3> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Tangents IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Textures0 IList<Vector2> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Textures1 IList<Vector2> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Weights0 IList<Vector4> } }
+NS SharpGLTF.Geometry.VertexTypes { CLASS VertexColumns { METHOD:SET Weights1 IList<Vector4> } }
+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 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 IVertexPosition { METHOD:ABSTRACT SetNormal Void (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexPosition { METHOD:ABSTRACT SetPosition Void (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexPosition { METHOD:ABSTRACT SetTangent Void (Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexPosition { METHOD:ABSTRACT Transform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexPosition { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT SetJoints Void (Int32, Vector4, Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { INTERFACE IVertexSkinning { METHOD:ABSTRACT Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { FIELD Color Vector4 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexColor1 { METHOD:CONSTRUCTOR (Vector4) } }
+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 (Vector4, Vector2) } }
+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 (Vector4, Vector2, Vector2) } }
+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 (Vector4, Vector4, Vector2, Vector2) } }
+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: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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints16x4 { METHOD:CONSTRUCTOR (Int32, Int32) } }
+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: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:CONSTRUCTOR (Int32) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexJoints8x4 { METHOD:CONSTRUCTOR (Int32, Int32) } }
+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: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 (Single, Single, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:CONSTRUCTOR (Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPosition { USING IVertexPosition } }
+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 (Single, Single, Single, Single, Single, Single) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:CONSTRUCTOR (Vector3, Vector3) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormal { USING IVertexPosition } }
+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 (Vector3, Vector3, Vector4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL Transform Void (Matrix4x4) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexPositionNormalTangent { USING IVertexPosition } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { FIELD TexCoord Vector2 } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:CONSTRUCTOR (Vector2) } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { METHOD:VIRTUAL Validate Void () } }
+NS SharpGLTF.Geometry.VertexTypes { STRUCT VertexTexture1 { USING IVertexMaterial } }
+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 MaterialChannelBuilder (KnownChannels) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD GetChannel MaterialChannelBuilder (String) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD UseChannel MaterialChannelBuilder (KnownChannels) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD UseChannel MaterialChannelBuilder (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 WithFallback MaterialBuilder (MaterialBuilder) } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithMetallicRoughnessShader MaterialBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialBuilder { METHOD WithShade 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<MaterialChannelBuilder> } }
+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 MaterialChannelBuilder { METHOD UseTexture TextureBuilder () } }
+NS SharpGLTF.Materials { CLASS MaterialChannelBuilder { METHOD:GET Key String } }
+NS SharpGLTF.Materials { CLASS MaterialChannelBuilder { METHOD:GET Parameter Vector4 } }
+NS SharpGLTF.Materials { CLASS MaterialChannelBuilder { METHOD:GET Texture TextureBuilder } }
+NS SharpGLTF.Materials { CLASS MaterialChannelBuilder { METHOD:SET Parameter Vector4 } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD WithCoordinateSet TextureBuilder (Int32) } }
+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 (TextureMipMapFilter=LINEAR, TextureInterpolationFilter=LINEAR, TextureWrapMode=REPEAT, TextureWrapMode=REPEAT) } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET CoordinateSet Int32 } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:GET ImageContent 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 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 ImageContent 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 WrapS TextureWrapMode } }
+NS SharpGLTF.Materials { CLASS TextureBuilder { METHOD:SET WrapT TextureWrapMode } }
+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,TvP,TvM,JvS>, Mesh, Matrix4x4, 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 (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, MaterialChannelBuilder) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CopyTo Void (MaterialChannelBuilder, MaterialChannel) } }
+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,JvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, MeshBuilder<Material,TvP,TvM,JvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMesh Mesh (ModelRoot, MeshBuilder<MaterialBuilder,TvP,TvM,JvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, Func<TMaterial,Material>, params MeshBuilder[]<TMaterial,TvP,TvM,JvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, params MeshBuilder[]<Material,TvP,TvM,JvS>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION CreateMeshes IReadOnlyList<Mesh> (ModelRoot, params MeshBuilder[]<MaterialBuilder,TvP,TvM,JvS>) } }
+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 Triangulate IEnumerable<ValueTuple<ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,Material>> (Mesh, Matrix4x4) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,Material>> (MeshPrimitive, Matrix4x4, IReadOnlyDictionary<Vector3,Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,Material>> (Node, Boolean) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION Triangulate IEnumerable<ValueTuple<ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,ValueTuple<TvP,TvM,JvS>,Material>> (Scene) } }
+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 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 WithScaleAnimation Node (Node, String, IReadOnlyDictionary<Single,Vector3>) } }
+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 WithUnlit Material (Material) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, MemoryAccessor) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Single>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector2>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector3>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessor MeshPrimitive (MeshPrimitive, String, IReadOnlyList<Vector4>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IEnumerable<MemoryAccessor>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<TVertex>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<ValueTuple<TVertex,TValues,TJoints>>) } }
+NS SharpGLTF.Schema2 { CLASS:STATIC Schema2Toolkit { METHOD:EXTENSION WithVertexAccessors MeshPrimitive (MeshPrimitive, IReadOnlyList<ValueTuple<TVertex,TValues>>) } }

tests/SharpGLTF.Tests/SharpGLTF.Tests.csproj

@@ -22,6 +22,12 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="Assets\API.Core.1.0.0-alpha0005.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Assets\API.Toolkit.1.0.0-alpha0005.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="Assets\Texture1.jpg">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>