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

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