diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs b/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs new file mode 100644 index 000000000..0dbcf723a --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs @@ -0,0 +1,115 @@ +using System; +using System.IO; + +namespace UniGLTF +{ + public class ArraySerialization : FunctionSerializationBase + { + IValueSerialization m_inner; + + public ArraySerialization(Type t, IValueSerialization inner) + { + ValueType = t; + m_inner = inner; + } + public override void GenerateDeserializer(StreamWriter writer, string callName) + { + var itemCallName = callName + "_ARRAY"; + + writer.Write(@" +public static $0 $2(ListTreeNode parsed) +{ + var value = new $1[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = $3; + } + return value; +} +" +.Replace("$0", UniJSON.JsonSchemaAttribute.GetTypeName(ValueType)) +.Replace("$1", m_inner.ValueType.Name) +.Replace("$2", callName) +.Replace("$3", m_inner.GenerateDeserializerCall(itemCallName, "x")) +); + + if (!m_inner.IsInline) + { + m_inner.GenerateDeserializer(writer, itemCallName); + } + } + } + + public class ListSerialization : FunctionSerializationBase + { + IValueSerialization m_inner; + + public ListSerialization(Type t, IValueSerialization inner) + { + ValueType = t; + m_inner = inner; + } + public override void GenerateDeserializer(StreamWriter writer, string callName) + { + var itemCallName = callName + "_LIST"; + writer.Write(@" +public static $0 $2(ListTreeNode parsed) +{ + var value = new List<$1>(); + foreach(var x in parsed.ArrayItems()) + { + value.Add($3); + } + return value; +}" +.Replace("$0", UniJSON.JsonSchemaAttribute.GetTypeName(ValueType)) +.Replace("$1", m_inner.ValueType.Name) +.Replace("$2", callName) +.Replace("$3", m_inner.GenerateDeserializerCall(itemCallName, "x")) +); + + if (!m_inner.IsInline) + { + m_inner.GenerateDeserializer(writer, itemCallName); + } + } + } + + public class StringKeyDictionarySerialization : FunctionSerializationBase + { + IValueSerialization m_inner; + + public StringKeyDictionarySerialization(Type t, IValueSerialization inner) + { + ValueType = t; + m_inner = inner; + } + public override void GenerateDeserializer(StreamWriter writer, string callName) + { + var itemCallName = callName + "_DICT"; + writer.Write(@" + +public static $0 $2(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), $3); + } + return value; +} +" +.Replace("$0", UniJSON.JsonSchemaAttribute.GetTypeName(ValueType)) +.Replace("$1", m_inner.ValueType.Name) +.Replace("$2", callName) +.Replace("$3", m_inner.GenerateDeserializerCall(itemCallName, "kv.Value")) +); + + if (!m_inner.IsInline) + { + m_inner.GenerateDeserializer(writer, itemCallName); + } + } + } +} \ No newline at end of file diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs.meta b/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs.meta new file mode 100644 index 000000000..bf9f1d2a2 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/CollectionSerialization.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: e85f0c5204f5ac3429503462ef29cdae +timeCreated: 1565259169 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/DeserializerGenerator.cs b/Assets/VRM/UniGLTF/Editor/Serialization/DeserializerGenerator.cs index bfd916065..c6bb8bbae 100644 --- a/Assets/VRM/UniGLTF/Editor/Serialization/DeserializerGenerator.cs +++ b/Assets/VRM/UniGLTF/Editor/Serialization/DeserializerGenerator.cs @@ -1,178 +1,61 @@ -using System; -using System.Collections; -using System.Collections.Generic; -using System.IO; -using System.Linq; +using System.IO; using System.Reflection; using System.Text; -using UniJSON; using UnityEditor; using UnityEngine; namespace UniGLTF { - public class FieldSerializationInfo - { - FieldInfo m_fi; - string m_path; - - JsonSchemaAttribute m_attr; - - ObjectSerializationInfo m_child; - - public FieldSerializationInfo(FieldInfo fi, string path) - { - m_fi = fi; - m_path = path; - m_attr = fi.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(JsonSchemaAttribute)) as JsonSchemaAttribute; - - var suffix = default(string); - var t = default(Type); - var isDictionary = default(bool); - GetCollectionType(fi.FieldType, out suffix, out t, out isDictionary); - - if (t == typeof(object)) - { - // 終わり - return; - } - if (fi.IsLiteral && !fi.IsInitOnly) - { - // const - // 終わり - return; - } - if (t.IsClass && t.GetFields(DeserializerGenerator.FIELD_FLAGS).Length == 0) - { - // 終わり - return; - } - if (IsPrimitive(t)) - { - // 終わり - return; - } - - m_child = new ObjectSerializationInfo(t, m_path + "/" + m_fi.Name + suffix); - } - - static void GetCollectionType(Type t, out string suffix, out Type collectionType, out bool isDictionary) - { - if (t.IsArray) - { - suffix = "[]"; - collectionType = t.GetElementType(); - isDictionary = false; - return; - } - if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>)) - { - suffix = "[]"; - collectionType = t.GetGenericArguments()[0]; - isDictionary = false; - return; - } - if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Dictionary<,>) - && t.GetGenericArguments()[0] == typeof(string)) - { - suffix = ""; - collectionType = t.GetGenericArguments()[1]; - isDictionary = true; - return; - } - - suffix = ""; - collectionType = t; - isDictionary = false; - } - - static bool IsPrimitive(Type t) - { - if (t == typeof(sbyte) - || t == typeof(short) - || t == typeof(int) - || t == typeof(long) - || t == typeof(byte) - || t == typeof(ushort) - || t == typeof(uint) - || t == typeof(ulong) - || t == typeof(float) - || t == typeof(double) - || t == typeof(string) - || t == typeof(bool) - ) - { - return true; - } - - if (t.IsEnum) - { - return true; - } - - return false; - } - - public override string ToString() - { - var sb = new StringBuilder(); - - var typeName = BaseJsonSchemaAttribute.GetTypeName(m_fi.FieldType); - - if (m_attr != null) - { - sb.AppendLine(string.Format("{0}/{1}: {2}", m_path, m_fi.Name, m_attr.GetInfo(m_fi))); - } - else - { - sb.AppendLine(string.Format("{0}/{1}: {2}", m_path, m_fi.Name, typeName)); - } - - if (m_child != null) - { - sb.Append(m_child.ToString()); - } - return sb.ToString(); - } - } - - public class ObjectSerializationInfo - { - string m_path; - FieldSerializationInfo[] m_fsi; - - public ObjectSerializationInfo(Type t, string path) - { - m_path = path; - m_fsi = t.GetFields(DeserializerGenerator.FIELD_FLAGS).Select(x => - { - return new FieldSerializationInfo(x, path); - }).ToArray(); - } - - public override string ToString() - { - var sb = new StringBuilder(); - foreach (var x in m_fsi) - { - sb.Append(x.ToString()); - } - return sb.ToString(); - } - } - public static class DeserializerGenerator { public const BindingFlags FIELD_FLAGS = BindingFlags.Instance | BindingFlags.Public; + static string OutPath + { + get + { + return Path.Combine(UnityEngine.Application.dataPath, + "VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs"); + } + } + /// /// AOT向けにデシリアライザを生成する /// [MenuItem(VRM.VRMVersion.MENU + "/Generate Deserializer")] static void GenerateSerializer() { - var info = new ObjectSerializationInfo(typeof(glTF), "gltf"); + var info = new ObjectSerialization(typeof(glTF), "gltf"); Debug.Log(info); + + using (var s = File.Open(OutPath, FileMode.Create)) + using (var w = new StreamWriter(s, Encoding.UTF8)) + { + // header + w.Write(@" +using UniJSON; +using System; +using System.Collections.Generic; +using VRM; +using UnityEngine; + +namespace UniGLTF { + +public static class GltfDeserializer +{ + +"); + + info.GenerateDeserializer(w, "Deserialize"); + + // footer + w.Write(@" +} // GltfDeserializer +} // UniGLTF +"); + + Debug.LogFormat("write: {0}", OutPath); + } } } } diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs b/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs new file mode 100644 index 000000000..3ca000776 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs @@ -0,0 +1,152 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using UniJSON; + +namespace UniGLTF +{ + public class FieldSerializationInfo + { + FieldInfo m_fi; + public FieldInfo FieldInfo + { + get { return m_fi; } + } + + public string Name + { + get { return FieldInfo.Name; } + } + + public string Path + { + get; + private set; + } + + public string FunctionName + { + get + { + return "Deserialize_" + Path + .Replace("/", "_") + .Replace("[]", "_") + ; + } + } + + JsonSchemaAttribute m_attr; + + public IValueSerialization Serialization + { + get; + private set; + } + + public FieldSerializationInfo(FieldInfo fi, string path) + { + m_fi = fi; + Path = path + "/" + fi.Name; + m_attr = fi.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(JsonSchemaAttribute)) as JsonSchemaAttribute; + + Serialization = GetSerialization(m_fi.FieldType, Path); + } + + static IValueSerialization GetSerialization(Type t, string path) + { + if (t.IsArray) + { + return new ArraySerialization(t, + GetSerialization(t.GetElementType(), path + "[]")); + } + else if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>)) + { + return new ListSerialization(t, + GetSerialization(t.GetGenericArguments()[0], path + "[]")); + } + else if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Dictionary<,>) + && t.GetGenericArguments()[0] == typeof(string)) + { + return new StringKeyDictionarySerialization(t, + GetSerialization(t.GetGenericArguments()[1], path)); + } + + // GetCollectionType(fi.FieldType, out suffix, out t); + if (t == typeof(sbyte)) + { + return new Int8Serialization(); + } + else if (t == typeof(short)) + { + return new Int16Serialization(); + } + else if (t == typeof(int)) + { + return new Int32Serialization(); + } + else if (t == typeof(long)) + { + return new Int64Serialization(); + } + else if (t == typeof(byte)) + { + return new UInt8Serialization(); + } + else if (t == typeof(ushort)) + { + return new UInt16Serialization(); + } + else if (t == typeof(uint)) + { + return new UInt32Serialization(); + } + else if (t == typeof(ulong)) + { + return new UInt64Serialization(); + } + else if (t == typeof(float)) + { + return new SingleSerialization(); + } + else if (t == typeof(double)) + { + return new DoubleSerialization(); + } + else if (t == typeof(string)) + { + return new StringSerialization(); + } + else if (t == typeof(bool)) + { + return new BooleanSerialization(); + } + else if (t.IsEnum) + { + return new EnumIntSerialization(t); + } + + return new ObjectSerialization(t, path); + } + + public override string ToString() + { + var sb = new StringBuilder(); + + var typeName = BaseJsonSchemaAttribute.GetTypeName(m_fi.FieldType); + + if (m_attr != null) + { + sb.AppendLine(string.Format("{0}: {1}", Path, m_attr.GetInfo(m_fi))); + } + else + { + sb.AppendLine(string.Format("{0}: {1}", Path, typeName)); + } + + sb.Append(Serialization.ToString()); + return sb.ToString(); + } + } +} \ No newline at end of file diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs.meta b/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs.meta new file mode 100644 index 000000000..d02384d16 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/FieldSerializationInfo.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 3c26deb26a3941642a30691d374199da +timeCreated: 1565256318 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs b/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs new file mode 100644 index 000000000..dba6d82b9 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs @@ -0,0 +1,17 @@ +using System; +using System.IO; + +namespace UniGLTF +{ + // Use this for initialization + public interface IValueSerialization + { + Type ValueType { get; } + + bool IsInline { get; } + + string GenerateDeserializerCall(string callName, string argName); + + void GenerateDeserializer(StreamWriter writer, string callName); + } +} diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs.meta b/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs.meta new file mode 100644 index 000000000..8bcb914ef --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/IValueSerialization.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 199c91bbade4ea043928e29946a28502 +timeCreated: 1565256001 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs b/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs new file mode 100644 index 000000000..6f9d20da8 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs @@ -0,0 +1,112 @@ +using System; +using System.IO; +using System.Linq; +using System.Text; + +namespace UniGLTF +{ + public abstract class FunctionSerializationBase : IValueSerialization + { + public Type ValueType + { + get; + protected set; + } + + public bool IsInline + { + get { return false; } + } + + public abstract void GenerateDeserializer(StreamWriter writer, string callName); + + public string GenerateDeserializerCall(string callName, string argName) + { + return string.Format("{0}({1})", callName, argName); + } + } + + public class ObjectSerialization : FunctionSerializationBase + { + string m_path; + FieldSerializationInfo[] m_fsi; + + public ObjectSerialization(Type t, string path) + { + ValueType = t; + m_path = path; + m_fsi = t.GetFields(DeserializerGenerator.FIELD_FLAGS) + .Where(x => + { + if (x.FieldType == typeof(object)) + { + // object. coannot serialize + return false; + } + if (x.IsLiteral && !x.IsInitOnly) + { + // const + return false; + } + return true; + }) + .Select(x => + { + return new FieldSerializationInfo(x, path); + }).ToArray(); + } + + public override string ToString() + { + var sb = new StringBuilder(); + foreach (var x in m_fsi) + { + sb.Append(x.ToString()); + } + return sb.ToString(); + } + + public override void GenerateDeserializer(StreamWriter writer, string parentName) + { + writer.Write(@" +public static $0 $2(ListTreeNode parsed) +{ + var value = new $0(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); +" +.Replace("$0", ValueType.Name) +.Replace("$2", parentName) +); + + foreach (var f in m_fsi) + { + writer.Write(@" + if(key==""$0""){ + value.$0 = $1; + continue; + } +" +.Replace("$0", f.Name) +.Replace("$1", f.Serialization.GenerateDeserializerCall(f.FunctionName, "kv.Value")) +); + } + + writer.Write(@" + } + return value; +} +"); + + foreach (var f in m_fsi) + { + if (!f.Serialization.IsInline) + { + f.Serialization.GenerateDeserializer(writer, f.FunctionName); + } + } + } + } +} diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs.meta b/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs.meta new file mode 100644 index 000000000..7b41b7514 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/ObjectSerialization.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 87a20b1fb7336e34bbc61c9d7476c6db +timeCreated: 1565256016 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs b/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs new file mode 100644 index 000000000..396aa483f --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs @@ -0,0 +1,198 @@ +using System; +using System.IO; + +namespace UniGLTF +{ + public abstract class PrimitiveSerializationBase : IValueSerialization + { + public bool IsInline + { + get { return true; } + } + + public abstract Type ValueType { get; } + + public void GenerateDeserializer(StreamWriter writer, string callName) + { + throw new System.NotImplementedException(); + } + + public abstract string GenerateDeserializerCall(string callName, string argName); + } + + public class Int8Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(SByte); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetInt8()"; + } + } + + public class Int16Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Int16); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetInt16()"; + } + } + + public class Int32Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Int32); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetInt32()"; + } + } + + public class Int64Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Int64); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetInt64()"; + } + } + + public class UInt8Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Byte); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetUInt8()"; + } + } + + public class UInt16Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(UInt16); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetUInt16()"; + } + } + + public class UInt32Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(UInt32); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetUInt32()"; + } + } + + public class UInt64Serialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(UInt64); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetUInt64()"; + } + } + + public class SingleSerialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Single); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetSingle()"; + } + } + + public class DoubleSerialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Double); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetDouble()"; + } + } + + public class BooleanSerialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(Boolean); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetBoolean()"; + } + } + + public class StringSerialization : PrimitiveSerializationBase + { + public override Type ValueType + { + get { return typeof(String); } + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return argName + ".GetString()"; + } + } + + public class EnumIntSerialization : PrimitiveSerializationBase + { + Type m_type; + + public override Type ValueType + { + get { return m_type; } + } + + public EnumIntSerialization(Type t) + { + m_type = t; + } + + public override string GenerateDeserializerCall(string callName, string argName) + { + return string.Format("({0}){1}.GetInt32()", m_type.Name, argName); + } + } +} \ No newline at end of file diff --git a/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs.meta b/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs.meta new file mode 100644 index 000000000..8ee2f6f09 --- /dev/null +++ b/Assets/VRM/UniGLTF/Editor/Serialization/PrimitiveSerialization.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 8ddae9fc19efaec43a6d3aacad1c8d56 +timeCreated: 1565256889 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs b/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs new file mode 100644 index 000000000..585905f0f --- /dev/null +++ b/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs @@ -0,0 +1,2764 @@ + +using UniJSON; +using System; +using System.Collections.Generic; +using VRM; +using UnityEngine; + +namespace UniGLTF { + +public static class GltfDeserializer +{ + + +public static glTF Deserialize(ListTreeNode parsed) +{ + var value = new glTF(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="asset"){ + value.asset = Deserialize_gltf_asset(kv.Value); + continue; + } + + if(key=="buffers"){ + value.buffers = Deserialize_gltf_buffers(kv.Value); + continue; + } + + if(key=="bufferViews"){ + value.bufferViews = Deserialize_gltf_bufferViews(kv.Value); + continue; + } + + if(key=="accessors"){ + value.accessors = Deserialize_gltf_accessors(kv.Value); + continue; + } + + if(key=="textures"){ + value.textures = Deserialize_gltf_textures(kv.Value); + continue; + } + + if(key=="samplers"){ + value.samplers = Deserialize_gltf_samplers(kv.Value); + continue; + } + + if(key=="images"){ + value.images = Deserialize_gltf_images(kv.Value); + continue; + } + + if(key=="materials"){ + value.materials = Deserialize_gltf_materials(kv.Value); + continue; + } + + if(key=="meshes"){ + value.meshes = Deserialize_gltf_meshes(kv.Value); + continue; + } + + if(key=="nodes"){ + value.nodes = Deserialize_gltf_nodes(kv.Value); + continue; + } + + if(key=="skins"){ + value.skins = Deserialize_gltf_skins(kv.Value); + continue; + } + + if(key=="scene"){ + value.scene = kv.Value.GetInt32(); + continue; + } + + if(key=="scenes"){ + value.scenes = Deserialize_gltf_scenes(kv.Value); + continue; + } + + if(key=="animations"){ + value.animations = Deserialize_gltf_animations(kv.Value); + continue; + } + + if(key=="cameras"){ + value.cameras = Deserialize_gltf_cameras(kv.Value); + continue; + } + + if(key=="extensionsUsed"){ + value.extensionsUsed = Deserialize_gltf_extensionsUsed(kv.Value); + continue; + } + + if(key=="extensionsRequired"){ + value.extensionsRequired = Deserialize_gltf_extensionsRequired(kv.Value); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_extensions(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_extras(kv.Value); + continue; + } + + } + return value; +} + +public static glTFAssets Deserialize_gltf_asset(ListTreeNode parsed) +{ + var value = new glTFAssets(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="generator"){ + value.generator = kv.Value.GetString(); + continue; + } + + if(key=="version"){ + value.version = kv.Value.GetString(); + continue; + } + + if(key=="copyright"){ + value.copyright = kv.Value.GetString(); + continue; + } + + if(key=="minVersion"){ + value.minVersion = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_buffers(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_buffers_LIST(x)); + } + return value; +} +public static glTFBuffer Deserialize_gltf_buffers_LIST(ListTreeNode parsed) +{ + var value = new glTFBuffer(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="uri"){ + value.uri = kv.Value.GetString(); + continue; + } + + if(key=="byteLength"){ + value.byteLength = kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_bufferViews(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_bufferViews_LIST(x)); + } + return value; +} +public static glTFBufferView Deserialize_gltf_bufferViews_LIST(ListTreeNode parsed) +{ + var value = new glTFBufferView(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="buffer"){ + value.buffer = kv.Value.GetInt32(); + continue; + } + + if(key=="byteOffset"){ + value.byteOffset = kv.Value.GetInt32(); + continue; + } + + if(key=="byteLength"){ + value.byteLength = kv.Value.GetInt32(); + continue; + } + + if(key=="byteStride"){ + value.byteStride = kv.Value.GetInt32(); + continue; + } + + if(key=="target"){ + value.target = (glBufferTarget)kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_accessors(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_accessors_LIST(x)); + } + return value; +} +public static glTFAccessor Deserialize_gltf_accessors_LIST(ListTreeNode parsed) +{ + var value = new glTFAccessor(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="bufferView"){ + value.bufferView = kv.Value.GetInt32(); + continue; + } + + if(key=="byteOffset"){ + value.byteOffset = kv.Value.GetInt32(); + continue; + } + + if(key=="type"){ + value.type = kv.Value.GetString(); + continue; + } + + if(key=="componentType"){ + value.componentType = (glComponentType)kv.Value.GetInt32(); + continue; + } + + if(key=="count"){ + value.count = kv.Value.GetInt32(); + continue; + } + + if(key=="max"){ + value.max = Deserialize_gltf_accessors__max(kv.Value); + continue; + } + + if(key=="min"){ + value.min = Deserialize_gltf_accessors__min(kv.Value); + continue; + } + + if(key=="normalized"){ + value.normalized = kv.Value.GetBoolean(); + continue; + } + + if(key=="sparse"){ + value.sparse = Deserialize_gltf_accessors__sparse(kv.Value); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_accessors__max(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static Single[] Deserialize_gltf_accessors__min(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTFSparse Deserialize_gltf_accessors__sparse(ListTreeNode parsed) +{ + var value = new glTFSparse(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="count"){ + value.count = kv.Value.GetInt32(); + continue; + } + + if(key=="indices"){ + value.indices = Deserialize_gltf_accessors__sparse_indices(kv.Value); + continue; + } + + if(key=="values"){ + value.values = Deserialize_gltf_accessors__sparse_values(kv.Value); + continue; + } + + } + return value; +} + +public static glTFSparseIndices Deserialize_gltf_accessors__sparse_indices(ListTreeNode parsed) +{ + var value = new glTFSparseIndices(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="bufferView"){ + value.bufferView = kv.Value.GetInt32(); + continue; + } + + if(key=="byteOffset"){ + value.byteOffset = kv.Value.GetInt32(); + continue; + } + + if(key=="componentType"){ + value.componentType = (glComponentType)kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static glTFSparseValues Deserialize_gltf_accessors__sparse_values(ListTreeNode parsed) +{ + var value = new glTFSparseValues(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="bufferView"){ + value.bufferView = kv.Value.GetInt32(); + continue; + } + + if(key=="byteOffset"){ + value.byteOffset = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_textures(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_textures_LIST(x)); + } + return value; +} +public static glTFTexture Deserialize_gltf_textures_LIST(ListTreeNode parsed) +{ + var value = new glTFTexture(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="sampler"){ + value.sampler = kv.Value.GetInt32(); + continue; + } + + if(key=="source"){ + value.source = kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_samplers(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_samplers_LIST(x)); + } + return value; +} +public static glTFTextureSampler Deserialize_gltf_samplers_LIST(ListTreeNode parsed) +{ + var value = new glTFTextureSampler(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="magFilter"){ + value.magFilter = (glFilter)kv.Value.GetInt32(); + continue; + } + + if(key=="minFilter"){ + value.minFilter = (glFilter)kv.Value.GetInt32(); + continue; + } + + if(key=="wrapS"){ + value.wrapS = (glWrap)kv.Value.GetInt32(); + continue; + } + + if(key=="wrapT"){ + value.wrapT = (glWrap)kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_images(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_images_LIST(x)); + } + return value; +} +public static glTFImage Deserialize_gltf_images_LIST(ListTreeNode parsed) +{ + var value = new glTFImage(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="uri"){ + value.uri = kv.Value.GetString(); + continue; + } + + if(key=="bufferView"){ + value.bufferView = kv.Value.GetInt32(); + continue; + } + + if(key=="mimeType"){ + value.mimeType = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_materials(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_materials_LIST(x)); + } + return value; +} +public static glTFMaterial Deserialize_gltf_materials_LIST(ListTreeNode parsed) +{ + var value = new glTFMaterial(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="pbrMetallicRoughness"){ + value.pbrMetallicRoughness = Deserialize_gltf_materials__pbrMetallicRoughness(kv.Value); + continue; + } + + if(key=="normalTexture"){ + value.normalTexture = Deserialize_gltf_materials__normalTexture(kv.Value); + continue; + } + + if(key=="occlusionTexture"){ + value.occlusionTexture = Deserialize_gltf_materials__occlusionTexture(kv.Value); + continue; + } + + if(key=="emissiveTexture"){ + value.emissiveTexture = Deserialize_gltf_materials__emissiveTexture(kv.Value); + continue; + } + + if(key=="emissiveFactor"){ + value.emissiveFactor = Deserialize_gltf_materials__emissiveFactor(kv.Value); + continue; + } + + if(key=="alphaMode"){ + value.alphaMode = kv.Value.GetString(); + continue; + } + + if(key=="alphaCutoff"){ + value.alphaCutoff = kv.Value.GetSingle(); + continue; + } + + if(key=="doubleSided"){ + value.doubleSided = kv.Value.GetBoolean(); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_materials__extensions(kv.Value); + continue; + } + + } + return value; +} + +public static glTFPbrMetallicRoughness Deserialize_gltf_materials__pbrMetallicRoughness(ListTreeNode parsed) +{ + var value = new glTFPbrMetallicRoughness(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="baseColorTexture"){ + value.baseColorTexture = Deserialize_gltf_materials__pbrMetallicRoughness_baseColorTexture(kv.Value); + continue; + } + + if(key=="baseColorFactor"){ + value.baseColorFactor = Deserialize_gltf_materials__pbrMetallicRoughness_baseColorFactor(kv.Value); + continue; + } + + if(key=="metallicRoughnessTexture"){ + value.metallicRoughnessTexture = Deserialize_gltf_materials__pbrMetallicRoughness_metallicRoughnessTexture(kv.Value); + continue; + } + + if(key=="metallicFactor"){ + value.metallicFactor = kv.Value.GetSingle(); + continue; + } + + if(key=="roughnessFactor"){ + value.roughnessFactor = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static glTFMaterialBaseColorTextureInfo Deserialize_gltf_materials__pbrMetallicRoughness_baseColorTexture(ListTreeNode parsed) +{ + var value = new glTFMaterialBaseColorTextureInfo(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="texCoord"){ + value.texCoord = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_materials__pbrMetallicRoughness_baseColorFactor(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTFMaterialMetallicRoughnessTextureInfo Deserialize_gltf_materials__pbrMetallicRoughness_metallicRoughnessTexture(ListTreeNode parsed) +{ + var value = new glTFMaterialMetallicRoughnessTextureInfo(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="texCoord"){ + value.texCoord = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static glTFMaterialNormalTextureInfo Deserialize_gltf_materials__normalTexture(ListTreeNode parsed) +{ + var value = new glTFMaterialNormalTextureInfo(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="scale"){ + value.scale = kv.Value.GetSingle(); + continue; + } + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="texCoord"){ + value.texCoord = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static glTFMaterialOcclusionTextureInfo Deserialize_gltf_materials__occlusionTexture(ListTreeNode parsed) +{ + var value = new glTFMaterialOcclusionTextureInfo(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="strength"){ + value.strength = kv.Value.GetSingle(); + continue; + } + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="texCoord"){ + value.texCoord = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static glTFMaterialEmissiveTextureInfo Deserialize_gltf_materials__emissiveTexture(ListTreeNode parsed) +{ + var value = new glTFMaterialEmissiveTextureInfo(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="texCoord"){ + value.texCoord = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_materials__emissiveFactor(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTFMaterial_extensions Deserialize_gltf_materials__extensions(ListTreeNode parsed) +{ + var value = new glTFMaterial_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="KHR_materials_unlit"){ + value.KHR_materials_unlit = Deserialize_gltf_materials__extensions_KHR_materials_unlit(kv.Value); + continue; + } + + } + return value; +} + +public static glTF_KHR_materials_unlit Deserialize_gltf_materials__extensions_KHR_materials_unlit(ListTreeNode parsed) +{ + var value = new glTF_KHR_materials_unlit(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static List Deserialize_gltf_meshes(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_meshes_LIST(x)); + } + return value; +} +public static glTFMesh Deserialize_gltf_meshes_LIST(ListTreeNode parsed) +{ + var value = new glTFMesh(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="primitives"){ + value.primitives = Deserialize_gltf_meshes__primitives(kv.Value); + continue; + } + + if(key=="weights"){ + value.weights = Deserialize_gltf_meshes__weights(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_meshes__primitives(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_meshes__primitives_LIST(x)); + } + return value; +} +public static glTFPrimitives Deserialize_gltf_meshes__primitives_LIST(ListTreeNode parsed) +{ + var value = new glTFPrimitives(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="mode"){ + value.mode = kv.Value.GetInt32(); + continue; + } + + if(key=="indices"){ + value.indices = kv.Value.GetInt32(); + continue; + } + + if(key=="attributes"){ + value.attributes = Deserialize_gltf_meshes__primitives__attributes(kv.Value); + continue; + } + + if(key=="material"){ + value.material = kv.Value.GetInt32(); + continue; + } + + if(key=="targets"){ + value.targets = Deserialize_gltf_meshes__primitives__targets(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_meshes__primitives__extras(kv.Value); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_meshes__primitives__extensions(kv.Value); + continue; + } + + } + return value; +} + +public static glTFAttributes Deserialize_gltf_meshes__primitives__attributes(ListTreeNode parsed) +{ + var value = new glTFAttributes(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="POSITION"){ + value.POSITION = kv.Value.GetInt32(); + continue; + } + + if(key=="NORMAL"){ + value.NORMAL = kv.Value.GetInt32(); + continue; + } + + if(key=="TANGENT"){ + value.TANGENT = kv.Value.GetInt32(); + continue; + } + + if(key=="TEXCOORD_0"){ + value.TEXCOORD_0 = kv.Value.GetInt32(); + continue; + } + + if(key=="COLOR_0"){ + value.COLOR_0 = kv.Value.GetInt32(); + continue; + } + + if(key=="JOINTS_0"){ + value.JOINTS_0 = kv.Value.GetInt32(); + continue; + } + + if(key=="WEIGHTS_0"){ + value.WEIGHTS_0 = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_meshes__primitives__targets(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_meshes__primitives__targets_LIST(x)); + } + return value; +} +public static gltfMorphTarget Deserialize_gltf_meshes__primitives__targets_LIST(ListTreeNode parsed) +{ + var value = new gltfMorphTarget(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="POSITION"){ + value.POSITION = kv.Value.GetInt32(); + continue; + } + + if(key=="NORMAL"){ + value.NORMAL = kv.Value.GetInt32(); + continue; + } + + if(key=="TANGENT"){ + value.TANGENT = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static glTFPrimitives_extras Deserialize_gltf_meshes__primitives__extras(ListTreeNode parsed) +{ + var value = new glTFPrimitives_extras(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="targetNames"){ + value.targetNames = Deserialize_gltf_meshes__primitives__extras_targetNames(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_meshes__primitives__extras_targetNames(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(x.GetString()); + } + return value; +} +public static glTFPrimitives_extensions Deserialize_gltf_meshes__primitives__extensions(ListTreeNode parsed) +{ + var value = new glTFPrimitives_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static Single[] Deserialize_gltf_meshes__weights(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static List Deserialize_gltf_nodes(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_nodes_LIST(x)); + } + return value; +} +public static glTFNode Deserialize_gltf_nodes_LIST(ListTreeNode parsed) +{ + var value = new glTFNode(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="children"){ + value.children = Deserialize_gltf_nodes__children(kv.Value); + continue; + } + + if(key=="matrix"){ + value.matrix = Deserialize_gltf_nodes__matrix(kv.Value); + continue; + } + + if(key=="translation"){ + value.translation = Deserialize_gltf_nodes__translation(kv.Value); + continue; + } + + if(key=="rotation"){ + value.rotation = Deserialize_gltf_nodes__rotation(kv.Value); + continue; + } + + if(key=="scale"){ + value.scale = Deserialize_gltf_nodes__scale(kv.Value); + continue; + } + + if(key=="mesh"){ + value.mesh = kv.Value.GetInt32(); + continue; + } + + if(key=="skin"){ + value.skin = kv.Value.GetInt32(); + continue; + } + + if(key=="weights"){ + value.weights = Deserialize_gltf_nodes__weights(kv.Value); + continue; + } + + if(key=="camera"){ + value.camera = kv.Value.GetInt32(); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_nodes__extensions(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_nodes__extras(kv.Value); + continue; + } + + } + return value; +} + +public static Int32[] Deserialize_gltf_nodes__children(ListTreeNode parsed) +{ + var value = new Int32[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetInt32(); + } + return value; +} + +public static Single[] Deserialize_gltf_nodes__matrix(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static Single[] Deserialize_gltf_nodes__translation(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static Single[] Deserialize_gltf_nodes__rotation(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static Single[] Deserialize_gltf_nodes__scale(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static Single[] Deserialize_gltf_nodes__weights(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTFNode_extensions Deserialize_gltf_nodes__extensions(ListTreeNode parsed) +{ + var value = new glTFNode_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFNode_extra Deserialize_gltf_nodes__extras(ListTreeNode parsed) +{ + var value = new glTFNode_extra(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static List Deserialize_gltf_skins(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_skins_LIST(x)); + } + return value; +} +public static glTFSkin Deserialize_gltf_skins_LIST(ListTreeNode parsed) +{ + var value = new glTFSkin(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="inverseBindMatrices"){ + value.inverseBindMatrices = kv.Value.GetInt32(); + continue; + } + + if(key=="joints"){ + value.joints = Deserialize_gltf_skins__joints(kv.Value); + continue; + } + + if(key=="skeleton"){ + value.skeleton = kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static Int32[] Deserialize_gltf_skins__joints(ListTreeNode parsed) +{ + var value = new Int32[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetInt32(); + } + return value; +} + +public static List Deserialize_gltf_scenes(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_scenes_LIST(x)); + } + return value; +} +public static gltfScene Deserialize_gltf_scenes_LIST(ListTreeNode parsed) +{ + var value = new gltfScene(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="nodes"){ + value.nodes = Deserialize_gltf_scenes__nodes(kv.Value); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static Int32[] Deserialize_gltf_scenes__nodes(ListTreeNode parsed) +{ + var value = new Int32[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetInt32(); + } + return value; +} + +public static List Deserialize_gltf_animations(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_animations_LIST(x)); + } + return value; +} +public static glTFAnimation Deserialize_gltf_animations_LIST(ListTreeNode parsed) +{ + var value = new glTFAnimation(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="channels"){ + value.channels = Deserialize_gltf_animations__channels(kv.Value); + continue; + } + + if(key=="samplers"){ + value.samplers = Deserialize_gltf_animations__samplers(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_animations__channels(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_animations__channels_LIST(x)); + } + return value; +} +public static glTFAnimationChannel Deserialize_gltf_animations__channels_LIST(ListTreeNode parsed) +{ + var value = new glTFAnimationChannel(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="sampler"){ + value.sampler = kv.Value.GetInt32(); + continue; + } + + if(key=="target"){ + value.target = Deserialize_gltf_animations__channels__target(kv.Value); + continue; + } + + } + return value; +} + +public static glTFAnimationTarget Deserialize_gltf_animations__channels__target(ListTreeNode parsed) +{ + var value = new glTFAnimationTarget(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="node"){ + value.node = kv.Value.GetInt32(); + continue; + } + + if(key=="path"){ + value.path = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_animations__samplers(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_animations__samplers_LIST(x)); + } + return value; +} +public static glTFAnimationSampler Deserialize_gltf_animations__samplers_LIST(ListTreeNode parsed) +{ + var value = new glTFAnimationSampler(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="input"){ + value.input = kv.Value.GetInt32(); + continue; + } + + if(key=="interpolation"){ + value.interpolation = kv.Value.GetString(); + continue; + } + + if(key=="output"){ + value.output = kv.Value.GetInt32(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_cameras(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_cameras_LIST(x)); + } + return value; +} +public static glTFCamera Deserialize_gltf_cameras_LIST(ListTreeNode parsed) +{ + var value = new glTFCamera(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="orthographic"){ + value.orthographic = Deserialize_gltf_cameras__orthographic(kv.Value); + continue; + } + + if(key=="perspective"){ + value.perspective = Deserialize_gltf_cameras__perspective(kv.Value); + continue; + } + + if(key=="type"){ + value.type = (ProjectionType)kv.Value.GetInt32(); + continue; + } + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_cameras__extensions(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_cameras__extras(kv.Value); + continue; + } + + } + return value; +} + +public static glTFOrthographic Deserialize_gltf_cameras__orthographic(ListTreeNode parsed) +{ + var value = new glTFOrthographic(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="xmag"){ + value.xmag = kv.Value.GetSingle(); + continue; + } + + if(key=="ymag"){ + value.ymag = kv.Value.GetSingle(); + continue; + } + + if(key=="zfar"){ + value.zfar = kv.Value.GetSingle(); + continue; + } + + if(key=="znear"){ + value.znear = kv.Value.GetSingle(); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_cameras__orthographic_extensions(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_cameras__orthographic_extras(kv.Value); + continue; + } + + } + return value; +} + +public static glTFOrthographic_extensions Deserialize_gltf_cameras__orthographic_extensions(ListTreeNode parsed) +{ + var value = new glTFOrthographic_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFOrthographic_extras Deserialize_gltf_cameras__orthographic_extras(ListTreeNode parsed) +{ + var value = new glTFOrthographic_extras(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFPerspective Deserialize_gltf_cameras__perspective(ListTreeNode parsed) +{ + var value = new glTFPerspective(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="aspectRatio"){ + value.aspectRatio = kv.Value.GetSingle(); + continue; + } + + if(key=="yfov"){ + value.yfov = kv.Value.GetSingle(); + continue; + } + + if(key=="zfar"){ + value.zfar = kv.Value.GetSingle(); + continue; + } + + if(key=="znear"){ + value.znear = kv.Value.GetSingle(); + continue; + } + + if(key=="extensions"){ + value.extensions = Deserialize_gltf_cameras__perspective_extensions(kv.Value); + continue; + } + + if(key=="extras"){ + value.extras = Deserialize_gltf_cameras__perspective_extras(kv.Value); + continue; + } + + } + return value; +} + +public static glTFPerspective_extensions Deserialize_gltf_cameras__perspective_extensions(ListTreeNode parsed) +{ + var value = new glTFPerspective_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFPerspective_extras Deserialize_gltf_cameras__perspective_extras(ListTreeNode parsed) +{ + var value = new glTFPerspective_extras(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFCamera_extensions Deserialize_gltf_cameras__extensions(ListTreeNode parsed) +{ + var value = new glTFCamera_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static glTFCamera_extras Deserialize_gltf_cameras__extras(ListTreeNode parsed) +{ + var value = new glTFCamera_extras(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +public static List Deserialize_gltf_extensionsUsed(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(x.GetString()); + } + return value; +} +public static List Deserialize_gltf_extensionsRequired(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(x.GetString()); + } + return value; +} +public static glTF_extensions Deserialize_gltf_extensions(ListTreeNode parsed) +{ + var value = new glTF_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="VRM"){ + value.VRM = Deserialize_gltf_extensions_VRM(kv.Value); + continue; + } + + } + return value; +} + +public static glTF_VRM_extensions Deserialize_gltf_extensions_VRM(ListTreeNode parsed) +{ + var value = new glTF_VRM_extensions(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="exporterVersion"){ + value.exporterVersion = kv.Value.GetString(); + continue; + } + + if(key=="specVersion"){ + value.specVersion = kv.Value.GetString(); + continue; + } + + if(key=="meta"){ + value.meta = Deserialize_gltf_extensions_VRM_meta(kv.Value); + continue; + } + + if(key=="humanoid"){ + value.humanoid = Deserialize_gltf_extensions_VRM_humanoid(kv.Value); + continue; + } + + if(key=="firstPerson"){ + value.firstPerson = Deserialize_gltf_extensions_VRM_firstPerson(kv.Value); + continue; + } + + if(key=="blendShapeMaster"){ + value.blendShapeMaster = Deserialize_gltf_extensions_VRM_blendShapeMaster(kv.Value); + continue; + } + + if(key=="secondaryAnimation"){ + value.secondaryAnimation = Deserialize_gltf_extensions_VRM_secondaryAnimation(kv.Value); + continue; + } + + if(key=="materialProperties"){ + value.materialProperties = Deserialize_gltf_extensions_VRM_materialProperties(kv.Value); + continue; + } + + } + return value; +} + +public static glTF_VRM_Meta Deserialize_gltf_extensions_VRM_meta(ListTreeNode parsed) +{ + var value = new glTF_VRM_Meta(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="title"){ + value.title = kv.Value.GetString(); + continue; + } + + if(key=="version"){ + value.version = kv.Value.GetString(); + continue; + } + + if(key=="author"){ + value.author = kv.Value.GetString(); + continue; + } + + if(key=="contactInformation"){ + value.contactInformation = kv.Value.GetString(); + continue; + } + + if(key=="reference"){ + value.reference = kv.Value.GetString(); + continue; + } + + if(key=="texture"){ + value.texture = kv.Value.GetInt32(); + continue; + } + + if(key=="allowedUserName"){ + value.allowedUserName = kv.Value.GetString(); + continue; + } + + if(key=="violentUssageName"){ + value.violentUssageName = kv.Value.GetString(); + continue; + } + + if(key=="sexualUssageName"){ + value.sexualUssageName = kv.Value.GetString(); + continue; + } + + if(key=="commercialUssageName"){ + value.commercialUssageName = kv.Value.GetString(); + continue; + } + + if(key=="otherPermissionUrl"){ + value.otherPermissionUrl = kv.Value.GetString(); + continue; + } + + if(key=="licenseName"){ + value.licenseName = kv.Value.GetString(); + continue; + } + + if(key=="otherLicenseUrl"){ + value.otherLicenseUrl = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static glTF_VRM_Humanoid Deserialize_gltf_extensions_VRM_humanoid(ListTreeNode parsed) +{ + var value = new glTF_VRM_Humanoid(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="humanBones"){ + value.humanBones = Deserialize_gltf_extensions_VRM_humanoid_humanBones(kv.Value); + continue; + } + + if(key=="armStretch"){ + value.armStretch = kv.Value.GetSingle(); + continue; + } + + if(key=="legStretch"){ + value.legStretch = kv.Value.GetSingle(); + continue; + } + + if(key=="upperArmTwist"){ + value.upperArmTwist = kv.Value.GetSingle(); + continue; + } + + if(key=="lowerArmTwist"){ + value.lowerArmTwist = kv.Value.GetSingle(); + continue; + } + + if(key=="upperLegTwist"){ + value.upperLegTwist = kv.Value.GetSingle(); + continue; + } + + if(key=="lowerLegTwist"){ + value.lowerLegTwist = kv.Value.GetSingle(); + continue; + } + + if(key=="feetSpacing"){ + value.feetSpacing = kv.Value.GetSingle(); + continue; + } + + if(key=="hasTranslationDoF"){ + value.hasTranslationDoF = kv.Value.GetBoolean(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_humanoid_humanBones(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_humanoid_humanBones_LIST(x)); + } + return value; +} +public static glTF_VRM_HumanoidBone Deserialize_gltf_extensions_VRM_humanoid_humanBones_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_HumanoidBone(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="bone"){ + value.bone = kv.Value.GetString(); + continue; + } + + if(key=="node"){ + value.node = kv.Value.GetInt32(); + continue; + } + + if(key=="useDefaultValues"){ + value.useDefaultValues = kv.Value.GetBoolean(); + continue; + } + + if(key=="min"){ + value.min = Deserialize_gltf_extensions_VRM_humanoid_humanBones__min(kv.Value); + continue; + } + + if(key=="max"){ + value.max = Deserialize_gltf_extensions_VRM_humanoid_humanBones__max(kv.Value); + continue; + } + + if(key=="center"){ + value.center = Deserialize_gltf_extensions_VRM_humanoid_humanBones__center(kv.Value); + continue; + } + + if(key=="axisLength"){ + value.axisLength = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_humanoid_humanBones__min(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_humanoid_humanBones__max(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_humanoid_humanBones__center(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static glTF_VRM_Firstperson Deserialize_gltf_extensions_VRM_firstPerson(ListTreeNode parsed) +{ + var value = new glTF_VRM_Firstperson(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="firstPersonBone"){ + value.firstPersonBone = kv.Value.GetInt32(); + continue; + } + + if(key=="firstPersonBoneOffset"){ + value.firstPersonBoneOffset = Deserialize_gltf_extensions_VRM_firstPerson_firstPersonBoneOffset(kv.Value); + continue; + } + + if(key=="meshAnnotations"){ + value.meshAnnotations = Deserialize_gltf_extensions_VRM_firstPerson_meshAnnotations(kv.Value); + continue; + } + + if(key=="lookAtTypeName"){ + value.lookAtTypeName = kv.Value.GetString(); + continue; + } + + if(key=="lookAtHorizontalInner"){ + value.lookAtHorizontalInner = Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalInner(kv.Value); + continue; + } + + if(key=="lookAtHorizontalOuter"){ + value.lookAtHorizontalOuter = Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalOuter(kv.Value); + continue; + } + + if(key=="lookAtVerticalDown"){ + value.lookAtVerticalDown = Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalDown(kv.Value); + continue; + } + + if(key=="lookAtVerticalUp"){ + value.lookAtVerticalUp = Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalUp(kv.Value); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_firstPerson_firstPersonBoneOffset(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_firstPerson_meshAnnotations(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_firstPerson_meshAnnotations_LIST(x)); + } + return value; +} +public static glTF_VRM_MeshAnnotation Deserialize_gltf_extensions_VRM_firstPerson_meshAnnotations_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_MeshAnnotation(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="mesh"){ + value.mesh = kv.Value.GetInt32(); + continue; + } + + if(key=="firstPersonFlag"){ + value.firstPersonFlag = kv.Value.GetString(); + continue; + } + + } + return value; +} + +public static glTF_VRM_DegreeMap Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalInner(ListTreeNode parsed) +{ + var value = new glTF_VRM_DegreeMap(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="curve"){ + value.curve = Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalInner_curve(kv.Value); + continue; + } + + if(key=="xRange"){ + value.xRange = kv.Value.GetSingle(); + continue; + } + + if(key=="yRange"){ + value.yRange = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalInner_curve(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTF_VRM_DegreeMap Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalOuter(ListTreeNode parsed) +{ + var value = new glTF_VRM_DegreeMap(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="curve"){ + value.curve = Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalOuter_curve(kv.Value); + continue; + } + + if(key=="xRange"){ + value.xRange = kv.Value.GetSingle(); + continue; + } + + if(key=="yRange"){ + value.yRange = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_firstPerson_lookAtHorizontalOuter_curve(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTF_VRM_DegreeMap Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalDown(ListTreeNode parsed) +{ + var value = new glTF_VRM_DegreeMap(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="curve"){ + value.curve = Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalDown_curve(kv.Value); + continue; + } + + if(key=="xRange"){ + value.xRange = kv.Value.GetSingle(); + continue; + } + + if(key=="yRange"){ + value.yRange = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalDown_curve(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTF_VRM_DegreeMap Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalUp(ListTreeNode parsed) +{ + var value = new glTF_VRM_DegreeMap(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="curve"){ + value.curve = Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalUp_curve(kv.Value); + continue; + } + + if(key=="xRange"){ + value.xRange = kv.Value.GetSingle(); + continue; + } + + if(key=="yRange"){ + value.yRange = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_firstPerson_lookAtVerticalUp_curve(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTF_VRM_BlendShapeMaster Deserialize_gltf_extensions_VRM_blendShapeMaster(ListTreeNode parsed) +{ + var value = new glTF_VRM_BlendShapeMaster(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="blendShapeGroups"){ + value.blendShapeGroups = Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups_LIST(x)); + } + return value; +} +public static glTF_VRM_BlendShapeGroup Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_BlendShapeGroup(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="presetName"){ + value.presetName = kv.Value.GetString(); + continue; + } + + if(key=="binds"){ + value.binds = Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__binds(kv.Value); + continue; + } + + if(key=="materialValues"){ + value.materialValues = Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues(kv.Value); + continue; + } + + if(key=="isBinary"){ + value.isBinary = kv.Value.GetBoolean(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__binds(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__binds_LIST(x)); + } + return value; +} +public static glTF_VRM_BlendShapeBind Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__binds_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_BlendShapeBind(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="mesh"){ + value.mesh = kv.Value.GetInt32(); + continue; + } + + if(key=="index"){ + value.index = kv.Value.GetInt32(); + continue; + } + + if(key=="weight"){ + value.weight = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues_LIST(x)); + } + return value; +} +public static glTF_VRM_MaterialValueBind Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_MaterialValueBind(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="materialName"){ + value.materialName = kv.Value.GetString(); + continue; + } + + if(key=="propertyName"){ + value.propertyName = kv.Value.GetString(); + continue; + } + + if(key=="targetValue"){ + value.targetValue = Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues__targetValue(kv.Value); + continue; + } + + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_blendShapeMaster_blendShapeGroups__materialValues__targetValue(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + +public static glTF_VRM_SecondaryAnimation Deserialize_gltf_extensions_VRM_secondaryAnimation(ListTreeNode parsed) +{ + var value = new glTF_VRM_SecondaryAnimation(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="boneGroups"){ + value.boneGroups = Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups(kv.Value); + continue; + } + + if(key=="colliderGroups"){ + value.colliderGroups = Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups_LIST(x)); + } + return value; +} +public static glTF_VRM_SecondaryAnimationGroup Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_SecondaryAnimationGroup(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="comment"){ + value.comment = kv.Value.GetString(); + continue; + } + + if(key=="stiffiness"){ + value.stiffiness = kv.Value.GetSingle(); + continue; + } + + if(key=="gravityPower"){ + value.gravityPower = kv.Value.GetSingle(); + continue; + } + + if(key=="gravityDir"){ + value.gravityDir = Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__gravityDir(kv.Value); + continue; + } + + if(key=="dragForce"){ + value.dragForce = kv.Value.GetSingle(); + continue; + } + + if(key=="center"){ + value.center = kv.Value.GetInt32(); + continue; + } + + if(key=="hitRadius"){ + value.hitRadius = kv.Value.GetSingle(); + continue; + } + + if(key=="bones"){ + value.bones = Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__bones(kv.Value); + continue; + } + + if(key=="colliderGroups"){ + value.colliderGroups = Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__colliderGroups(kv.Value); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__gravityDir(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Int32[] Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__bones(ListTreeNode parsed) +{ + var value = new Int32[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetInt32(); + } + return value; +} + +public static Int32[] Deserialize_gltf_extensions_VRM_secondaryAnimation_boneGroups__colliderGroups(ListTreeNode parsed) +{ + var value = new Int32[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetInt32(); + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups_LIST(x)); + } + return value; +} +public static glTF_VRM_SecondaryAnimationColliderGroup Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_SecondaryAnimationColliderGroup(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="node"){ + value.node = kv.Value.GetInt32(); + continue; + } + + if(key=="colliders"){ + value.colliders = Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders(kv.Value); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders_LIST(x)); + } + return value; +} +public static glTF_VRM_SecondaryAnimationCollider Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_SecondaryAnimationCollider(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="offset"){ + value.offset = Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders__offset(kv.Value); + continue; + } + + if(key=="radius"){ + value.radius = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static Vector3 Deserialize_gltf_extensions_VRM_secondaryAnimation_colliderGroups__colliders__offset(ListTreeNode parsed) +{ + var value = new Vector3(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="x"){ + value.x = kv.Value.GetSingle(); + continue; + } + + if(key=="y"){ + value.y = kv.Value.GetSingle(); + continue; + } + + if(key=="z"){ + value.z = kv.Value.GetSingle(); + continue; + } + + } + return value; +} + +public static List Deserialize_gltf_extensions_VRM_materialProperties(ListTreeNode parsed) +{ + var value = new List(); + foreach(var x in parsed.ArrayItems()) + { + value.Add(Deserialize_gltf_extensions_VRM_materialProperties_LIST(x)); + } + return value; +} +public static glTF_VRM_Material Deserialize_gltf_extensions_VRM_materialProperties_LIST(ListTreeNode parsed) +{ + var value = new glTF_VRM_Material(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + if(key=="name"){ + value.name = kv.Value.GetString(); + continue; + } + + if(key=="shader"){ + value.shader = kv.Value.GetString(); + continue; + } + + if(key=="renderQueue"){ + value.renderQueue = kv.Value.GetInt32(); + continue; + } + + if(key=="floatProperties"){ + value.floatProperties = Deserialize_gltf_extensions_VRM_materialProperties__floatProperties(kv.Value); + continue; + } + + if(key=="vectorProperties"){ + value.vectorProperties = Deserialize_gltf_extensions_VRM_materialProperties__vectorProperties(kv.Value); + continue; + } + + if(key=="textureProperties"){ + value.textureProperties = Deserialize_gltf_extensions_VRM_materialProperties__textureProperties(kv.Value); + continue; + } + + if(key=="keywordMap"){ + value.keywordMap = Deserialize_gltf_extensions_VRM_materialProperties__keywordMap(kv.Value); + continue; + } + + if(key=="tagMap"){ + value.tagMap = Deserialize_gltf_extensions_VRM_materialProperties__tagMap(kv.Value); + continue; + } + + } + return value; +} + + +public static Dictionary Deserialize_gltf_extensions_VRM_materialProperties__floatProperties(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), kv.Value.GetSingle()); + } + return value; +} + + +public static Dictionary Deserialize_gltf_extensions_VRM_materialProperties__vectorProperties(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), Deserialize_gltf_extensions_VRM_materialProperties__vectorProperties_DICT(kv.Value)); + } + return value; +} + +public static Single[] Deserialize_gltf_extensions_VRM_materialProperties__vectorProperties_DICT(ListTreeNode parsed) +{ + var value = new Single[parsed.GetArrayCount()]; + int i=0; + foreach(var x in parsed.ArrayItems()) + { + value[i++] = x.GetSingle(); + } + return value; +} + + +public static Dictionary Deserialize_gltf_extensions_VRM_materialProperties__textureProperties(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), kv.Value.GetInt32()); + } + return value; +} + + +public static Dictionary Deserialize_gltf_extensions_VRM_materialProperties__keywordMap(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), kv.Value.GetBoolean()); + } + return value; +} + + +public static Dictionary Deserialize_gltf_extensions_VRM_materialProperties__tagMap(ListTreeNode parsed) +{ + var value = new Dictionary(); + foreach(var kv in parsed.ObjectItems()) + { + value.Add(kv.Key.GetString(), kv.Value.GetString()); + } + return value; +} + +public static gltf_extras Deserialize_gltf_extras(ListTreeNode parsed) +{ + var value = new gltf_extras(); + + foreach(var kv in parsed.ObjectItems()) + { + var key = kv.Key.GetString(); + + } + return value; +} + +} // GltfDeserializer +} // UniGLTF diff --git a/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs.meta b/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs.meta new file mode 100644 index 000000000..557bd37b3 --- /dev/null +++ b/Assets/VRM/UniGLTF/Scripts/IO/GltfDeserializer.g.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: fd51f973e67cbb448bab93da7ea596a8 +timeCreated: 1565245501 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/VRM/UniJSON/Scripts/Json/JsonSchemaAttribute.cs b/Assets/VRM/UniJSON/Scripts/Json/JsonSchemaAttribute.cs index 1fe0f40ca..21e13f5b9 100644 --- a/Assets/VRM/UniJSON/Scripts/Json/JsonSchemaAttribute.cs +++ b/Assets/VRM/UniJSON/Scripts/Json/JsonSchemaAttribute.cs @@ -119,7 +119,7 @@ namespace UniJSON } else if (t.GetGenericTypeDefinition() == typeof(Dictionary<,>)) { - return "Dict<" + string.Join(", ", t.GetGenericArguments().Select(x => x.Name).ToArray()) + ">"; + return "Dictionary<" + string.Join(", ", t.GetGenericArguments().Select(x => x.Name).ToArray()) + ">"; } } diff --git a/ProjectSettings/GraphicsSettings.asset b/ProjectSettings/GraphicsSettings.asset index 74d7b532b..d74737e5e 100644 --- a/ProjectSettings/GraphicsSettings.asset +++ b/ProjectSettings/GraphicsSettings.asset @@ -35,6 +35,7 @@ GraphicsSettings: - {fileID: 15106, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0} + - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0} m_PreloadedShaders: [] m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0} diff --git a/ProjectSettings/ProjectSettings.asset b/ProjectSettings/ProjectSettings.asset index fb5039558..20ca387bf 100644 --- a/ProjectSettings/ProjectSettings.asset +++ b/ProjectSettings/ProjectSettings.asset @@ -70,6 +70,8 @@ PlayerSettings: captureSingleScreen: 0 muteOtherAudioSources: 0 Prepare IOS For Recording: 0 + deferSystemGesturesMode: 0 + hideHomeButton: 0 submitAnalytics: 1 usePlayerLog: 1 bakeCollisionMeshes: 0 @@ -99,6 +101,8 @@ PlayerSettings: n3dsEnableVSync: 0 ignoreAlphaClear: 0 xboxOneResolution: 0 + xboxOneSResolution: 0 + xboxOneXResolution: 3 xboxOneMonoLoggingLevel: 0 xboxOneLoggingLevel: 1 videoMemoryForVertexBuffers: 0 @@ -172,15 +176,21 @@ PlayerSettings: iPhone47inSplashScreen: {fileID: 0} iPhone55inPortraitSplashScreen: {fileID: 0} iPhone55inLandscapeSplashScreen: {fileID: 0} + iPhone58inPortraitSplashScreen: {fileID: 0} + iPhone58inLandscapeSplashScreen: {fileID: 0} iPadPortraitSplashScreen: {fileID: 0} iPadHighResPortraitSplashScreen: {fileID: 0} iPadLandscapeSplashScreen: {fileID: 0} iPadHighResLandscapeSplashScreen: {fileID: 0} appleTVSplashScreen: {fileID: 0} + appleTVSplashScreen2x: {fileID: 0} tvOSSmallIconLayers: [] + tvOSSmallIconLayers2x: [] tvOSLargeIconLayers: [] tvOSTopShelfImageLayers: [] + tvOSTopShelfImageLayers2x: [] tvOSTopShelfImageWideLayers: [] + tvOSTopShelfImageWideLayers2x: [] iOSLaunchScreenType: 0 iOSLaunchScreenPortrait: {fileID: 0} iOSLaunchScreenLandscape: {fileID: 0} @@ -277,6 +287,9 @@ PlayerSettings: switchTitleNames_9: switchTitleNames_10: switchTitleNames_11: + switchTitleNames_12: + switchTitleNames_13: + switchTitleNames_14: switchPublisherNames_0: switchPublisherNames_1: switchPublisherNames_2: @@ -289,6 +302,9 @@ PlayerSettings: switchPublisherNames_9: switchPublisherNames_10: switchPublisherNames_11: + switchPublisherNames_12: + switchPublisherNames_13: + switchPublisherNames_14: switchIcons_0: {fileID: 0} switchIcons_1: {fileID: 0} switchIcons_2: {fileID: 0} @@ -301,6 +317,9 @@ PlayerSettings: switchIcons_9: {fileID: 0} switchIcons_10: {fileID: 0} switchIcons_11: {fileID: 0} + switchIcons_12: {fileID: 0} + switchIcons_13: {fileID: 0} + switchIcons_14: {fileID: 0} switchSmallIcons_0: {fileID: 0} switchSmallIcons_1: {fileID: 0} switchSmallIcons_2: {fileID: 0} @@ -313,6 +332,9 @@ PlayerSettings: switchSmallIcons_9: {fileID: 0} switchSmallIcons_10: {fileID: 0} switchSmallIcons_11: {fileID: 0} + switchSmallIcons_12: {fileID: 0} + switchSmallIcons_13: {fileID: 0} + switchSmallIcons_14: {fileID: 0} switchManualHTML: switchAccessibleURLs: switchLegalInformation: @@ -354,6 +376,7 @@ PlayerSettings: switchLocalCommunicationIds_7: switchParentalControl: 0 switchAllowsScreenshot: 1 + switchAllowsVideoCapturing: 1 switchDataLossConfirmation: 0 switchSupportedNpadStyles: 3 switchSocketConfigEnabled: 0 @@ -496,7 +519,8 @@ PlayerSettings: webGLUseEmbeddedResources: 0 webGLUseWasm: 0 webGLCompressionFormat: 1 - scriptingDefineSymbols: {} + scriptingDefineSymbols: + 1: VRM_DEVELOP platformArchitecture: {} scriptingBackend: {} incrementalIl2cppBuild: {}