Merge pull request #1487 from ousttrue/fix10/fix_neutral

Fix10/fix neutral

Assets/VRM10/Editor/ScriptedImporter/VrmScriptedImporterEditorGUI.cs

@@ -50,6 +50,7 @@ namespace UniVRM10
             if (expressions.Preset?.LookDown != null) yield return ExpressionKey.LookDown.SubAssetKey;
             if (expressions.Preset?.LookLeft != null) yield return ExpressionKey.LookLeft.SubAssetKey;
             if (expressions.Preset?.LookRight != null) yield return ExpressionKey.LookRight.SubAssetKey;
+            if (expressions.Preset?.Neutral != null) yield return ExpressionKey.Neutral.SubAssetKey;
 
             if (expressions.Custom != null)
             {

Assets/VRM10/Runtime/Components/VRM10Object/VRM10ObjectExpression.cs

@@ -9,8 +9,6 @@ namespace UniVRM10
     [Serializable]
     public sealed class VRM10ObjectExpression
     {
-        public const string NEUTRAL_KEY = "Neutral";
-
         #region Preset
         [SerializeField, Header("Emotion")]
         public VRM10Expression Happy;

Assets/VRM10/Runtime/Format/Vrm/Deserializer.g.cs

@@ -2402,6 +2402,11 @@ public static Preset __expressions_Deserialize_Preset(JsonNode parsed)
             continue;
         }
 
+        if(key=="neutral"){
+            value.Neutral = __expressions__preset_Deserialize_Neutral(kv.Value);
+            continue;
+        }
+
     }
     return value;
 }
@@ -6333,6 +6338,237 @@ public static float[] __expressions__preset__lookRight__textureTransformBinds_IT
 	return value;
 } 
 
+public static Expression __expressions__preset_Deserialize_Neutral(JsonNode parsed)
+{
+    var value = new Expression();
+
+    foreach(var kv in parsed.ObjectItems())
+    {
+        var key = kv.Key.GetString();
+
+        if(key=="extensions"){
+            value.Extensions = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="extras"){
+            value.Extras = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="morphTargetBinds"){
+            value.MorphTargetBinds = __expressions__preset__neutral_Deserialize_MorphTargetBinds(kv.Value);
+            continue;
+        }
+
+        if(key=="materialColorBinds"){
+            value.MaterialColorBinds = __expressions__preset__neutral_Deserialize_MaterialColorBinds(kv.Value);
+            continue;
+        }
+
+        if(key=="textureTransformBinds"){
+            value.TextureTransformBinds = __expressions__preset__neutral_Deserialize_TextureTransformBinds(kv.Value);
+            continue;
+        }
+
+        if(key=="isBinary"){
+            value.IsBinary = kv.Value.GetBoolean();
+            continue;
+        }
+
+        if(key=="overrideBlink"){
+            value.OverrideBlink = (ExpressionOverrideType)Enum.Parse(typeof(ExpressionOverrideType), kv.Value.GetString(), true);
+            continue;
+        }
+
+        if(key=="overrideLookAt"){
+            value.OverrideLookAt = (ExpressionOverrideType)Enum.Parse(typeof(ExpressionOverrideType), kv.Value.GetString(), true);
+            continue;
+        }
+
+        if(key=="overrideMouth"){
+            value.OverrideMouth = (ExpressionOverrideType)Enum.Parse(typeof(ExpressionOverrideType), kv.Value.GetString(), true);
+            continue;
+        }
+
+    }
+    return value;
+}
+
+public static List<MorphTargetBind> __expressions__preset__neutral_Deserialize_MorphTargetBinds(JsonNode parsed)
+{
+    var value = new List<MorphTargetBind>();
+    foreach(var x in parsed.ArrayItems())
+    {
+        value.Add(__expressions__preset__neutral_Deserialize_MorphTargetBinds_ITEM(x));
+    }
+	return value;
+} 
+
+public static MorphTargetBind __expressions__preset__neutral_Deserialize_MorphTargetBinds_ITEM(JsonNode parsed)
+{
+    var value = new MorphTargetBind();
+
+    foreach(var kv in parsed.ObjectItems())
+    {
+        var key = kv.Key.GetString();
+
+        if(key=="extensions"){
+            value.Extensions = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="extras"){
+            value.Extras = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="node"){
+            value.Node = 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<MaterialColorBind> __expressions__preset__neutral_Deserialize_MaterialColorBinds(JsonNode parsed)
+{
+    var value = new List<MaterialColorBind>();
+    foreach(var x in parsed.ArrayItems())
+    {
+        value.Add(__expressions__preset__neutral_Deserialize_MaterialColorBinds_ITEM(x));
+    }
+	return value;
+} 
+
+public static MaterialColorBind __expressions__preset__neutral_Deserialize_MaterialColorBinds_ITEM(JsonNode parsed)
+{
+    var value = new MaterialColorBind();
+
+    foreach(var kv in parsed.ObjectItems())
+    {
+        var key = kv.Key.GetString();
+
+        if(key=="extensions"){
+            value.Extensions = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="extras"){
+            value.Extras = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="material"){
+            value.Material = kv.Value.GetInt32();
+            continue;
+        }
+
+        if(key=="type"){
+            value.Type = (MaterialColorType)Enum.Parse(typeof(MaterialColorType), kv.Value.GetString(), true);
+            continue;
+        }
+
+        if(key=="targetValue"){
+            value.TargetValue = __expressions__preset__neutral__materialColorBinds_ITEM_Deserialize_TargetValue(kv.Value);
+            continue;
+        }
+
+    }
+    return value;
+}
+
+public static float[] __expressions__preset__neutral__materialColorBinds_ITEM_Deserialize_TargetValue(JsonNode parsed)
+{
+    var value = new float[parsed.GetArrayCount()];
+    int i=0;
+    foreach(var x in parsed.ArrayItems())
+    {
+        value[i++] = x.GetSingle();
+    }
+	return value;
+} 
+
+public static List<TextureTransformBind> __expressions__preset__neutral_Deserialize_TextureTransformBinds(JsonNode parsed)
+{
+    var value = new List<TextureTransformBind>();
+    foreach(var x in parsed.ArrayItems())
+    {
+        value.Add(__expressions__preset__neutral_Deserialize_TextureTransformBinds_ITEM(x));
+    }
+	return value;
+} 
+
+public static TextureTransformBind __expressions__preset__neutral_Deserialize_TextureTransformBinds_ITEM(JsonNode parsed)
+{
+    var value = new TextureTransformBind();
+
+    foreach(var kv in parsed.ObjectItems())
+    {
+        var key = kv.Key.GetString();
+
+        if(key=="extensions"){
+            value.Extensions = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="extras"){
+            value.Extras = new glTFExtensionImport(kv.Value);
+            continue;
+        }
+
+        if(key=="material"){
+            value.Material = kv.Value.GetInt32();
+            continue;
+        }
+
+        if(key=="scale"){
+            value.Scale = __expressions__preset__neutral__textureTransformBinds_ITEM_Deserialize_Scale(kv.Value);
+            continue;
+        }
+
+        if(key=="offset"){
+            value.Offset = __expressions__preset__neutral__textureTransformBinds_ITEM_Deserialize_Offset(kv.Value);
+            continue;
+        }
+
+    }
+    return value;
+}
+
+public static float[] __expressions__preset__neutral__textureTransformBinds_ITEM_Deserialize_Scale(JsonNode parsed)
+{
+    var value = new float[parsed.GetArrayCount()];
+    int i=0;
+    foreach(var x in parsed.ArrayItems())
+    {
+        value[i++] = x.GetSingle();
+    }
+	return value;
+} 
+
+public static float[] __expressions__preset__neutral__textureTransformBinds_ITEM_Deserialize_Offset(JsonNode parsed)
+{
+    var value = new float[parsed.GetArrayCount()];
+    int i=0;
+    foreach(var x in parsed.ArrayItems())
+    {
+        value[i++] = x.GetSingle();
+    }
+	return value;
+} 
+
 public static Dictionary<string, Expression> __expressions_Deserialize_Custom(JsonNode parsed)
 {
     var value = new Dictionary<string, Expression>();

Assets/VRM10/Runtime/Format/Vrm/Format.g.cs

@@ -532,6 +532,9 @@ namespace UniGLTF.Extensions.VRMC_vrm
 
         // Definition of expression by weighted animation
         public Expression LookRight;
+
+        // Definition of expression by weighted animation
+        public Expression Neutral;
     }
 
     public class Expressions

Assets/VRM10/Runtime/Format/Vrm/Serializer.g.cs

@@ -2137,6 +2137,11 @@ public static void __expressions_Serialize_Preset(JsonFormatter f, Preset value)
         __expressions__preset_Serialize_LookRight(f, value.LookRight);
     }
 
+    if(value.Neutral!=null){
+        f.Key("neutral");                
+        __expressions__preset_Serialize_Neutral(f, value.Neutral);
+    }
+
     f.EndMap();
 }
 
@@ -5948,6 +5953,230 @@ public static void __expressions__preset__lookRight__textureTransformBinds_ITEM_
     f.EndList();
 }
 
+public static void __expressions__preset_Serialize_Neutral(JsonFormatter f, Expression value)
+{
+    f.BeginMap();
+
+
+    if(value.Extensions!=null){
+        f.Key("extensions");                
+        (value.Extensions as glTFExtension).Serialize(f);
+    }
+
+    if(value.Extras!=null){
+        f.Key("extras");                
+        (value.Extras as glTFExtension).Serialize(f);
+    }
+
+    if(value.MorphTargetBinds!=null&&value.MorphTargetBinds.Count()>=1){
+        f.Key("morphTargetBinds");                
+        __expressions__preset__neutral_Serialize_MorphTargetBinds(f, value.MorphTargetBinds);
+    }
+
+    if(value.MaterialColorBinds!=null&&value.MaterialColorBinds.Count()>=1){
+        f.Key("materialColorBinds");                
+        __expressions__preset__neutral_Serialize_MaterialColorBinds(f, value.MaterialColorBinds);
+    }
+
+    if(value.TextureTransformBinds!=null&&value.TextureTransformBinds.Count()>=1){
+        f.Key("textureTransformBinds");                
+        __expressions__preset__neutral_Serialize_TextureTransformBinds(f, value.TextureTransformBinds);
+    }
+
+    if(value.IsBinary.HasValue){
+        f.Key("isBinary");                
+        f.Value(value.IsBinary.GetValueOrDefault());
+    }
+
+    if(true){
+        f.Key("overrideBlink");                
+        f.Value(value.OverrideBlink.ToString());
+    }
+
+    if(true){
+        f.Key("overrideLookAt");                
+        f.Value(value.OverrideLookAt.ToString());
+    }
+
+    if(true){
+        f.Key("overrideMouth");                
+        f.Value(value.OverrideMouth.ToString());
+    }
+
+    f.EndMap();
+}
+
+public static void __expressions__preset__neutral_Serialize_MorphTargetBinds(JsonFormatter f, List<MorphTargetBind> value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    __expressions__preset__neutral_Serialize_MorphTargetBinds_ITEM(f, item);
+
+    }
+    f.EndList();
+}
+
+public static void __expressions__preset__neutral_Serialize_MorphTargetBinds_ITEM(JsonFormatter f, MorphTargetBind value)
+{
+    f.BeginMap();
+
+
+    if(value.Extensions!=null){
+        f.Key("extensions");                
+        (value.Extensions as glTFExtension).Serialize(f);
+    }
+
+    if(value.Extras!=null){
+        f.Key("extras");                
+        (value.Extras as glTFExtension).Serialize(f);
+    }
+
+    if(value.Node.HasValue){
+        f.Key("node");                
+        f.Value(value.Node.GetValueOrDefault());
+    }
+
+    if(value.Index.HasValue){
+        f.Key("index");                
+        f.Value(value.Index.GetValueOrDefault());
+    }
+
+    if(value.Weight.HasValue){
+        f.Key("weight");                
+        f.Value(value.Weight.GetValueOrDefault());
+    }
+
+    f.EndMap();
+}
+
+public static void __expressions__preset__neutral_Serialize_MaterialColorBinds(JsonFormatter f, List<MaterialColorBind> value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    __expressions__preset__neutral_Serialize_MaterialColorBinds_ITEM(f, item);
+
+    }
+    f.EndList();
+}
+
+public static void __expressions__preset__neutral_Serialize_MaterialColorBinds_ITEM(JsonFormatter f, MaterialColorBind value)
+{
+    f.BeginMap();
+
+
+    if(value.Extensions!=null){
+        f.Key("extensions");                
+        (value.Extensions as glTFExtension).Serialize(f);
+    }
+
+    if(value.Extras!=null){
+        f.Key("extras");                
+        (value.Extras as glTFExtension).Serialize(f);
+    }
+
+    if(value.Material.HasValue){
+        f.Key("material");                
+        f.Value(value.Material.GetValueOrDefault());
+    }
+
+    if(true){
+        f.Key("type");                
+        f.Value(value.Type.ToString());
+    }
+
+    if(value.TargetValue!=null&&value.TargetValue.Count()>=4){
+        f.Key("targetValue");                
+        __expressions__preset__neutral__materialColorBinds_ITEM_Serialize_TargetValue(f, value.TargetValue);
+    }
+
+    f.EndMap();
+}
+
+public static void __expressions__preset__neutral__materialColorBinds_ITEM_Serialize_TargetValue(JsonFormatter f, float[] value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    f.Value(item);
+
+    }
+    f.EndList();
+}
+
+public static void __expressions__preset__neutral_Serialize_TextureTransformBinds(JsonFormatter f, List<TextureTransformBind> value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    __expressions__preset__neutral_Serialize_TextureTransformBinds_ITEM(f, item);
+
+    }
+    f.EndList();
+}
+
+public static void __expressions__preset__neutral_Serialize_TextureTransformBinds_ITEM(JsonFormatter f, TextureTransformBind value)
+{
+    f.BeginMap();
+
+
+    if(value.Extensions!=null){
+        f.Key("extensions");                
+        (value.Extensions as glTFExtension).Serialize(f);
+    }
+
+    if(value.Extras!=null){
+        f.Key("extras");                
+        (value.Extras as glTFExtension).Serialize(f);
+    }
+
+    if(value.Material.HasValue){
+        f.Key("material");                
+        f.Value(value.Material.GetValueOrDefault());
+    }
+
+    if(value.Scale!=null&&value.Scale.Count()>=2){
+        f.Key("scale");                
+        __expressions__preset__neutral__textureTransformBinds_ITEM_Serialize_Scale(f, value.Scale);
+    }
+
+    if(value.Offset!=null&&value.Offset.Count()>=2){
+        f.Key("offset");                
+        __expressions__preset__neutral__textureTransformBinds_ITEM_Serialize_Offset(f, value.Offset);
+    }
+
+    f.EndMap();
+}
+
+public static void __expressions__preset__neutral__textureTransformBinds_ITEM_Serialize_Scale(JsonFormatter f, float[] value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    f.Value(item);
+
+    }
+    f.EndList();
+}
+
+public static void __expressions__preset__neutral__textureTransformBinds_ITEM_Serialize_Offset(JsonFormatter f, float[] value)
+{
+    f.BeginList();
+
+    foreach(var item in value)
+    {
+    f.Value(item);
+
+    }
+    f.EndList();
+}
+
 public static void __expressions_Serialize_Custom(JsonFormatter f, Dictionary<string, Expression> value)
 {
     f.BeginMap();

Assets/VRM10/Runtime/IO/Vrm10Exporter.cs

@@ -628,6 +628,7 @@ namespace UniVRM10
                     LookDown = ExportExpression(vrmController.Vrm.Expression.LookDown, vrmController, model, converter),
                     LookLeft = ExportExpression(vrmController.Vrm.Expression.LookLeft, vrmController, model, converter),
                     LookRight = ExportExpression(vrmController.Vrm.Expression.LookRight, vrmController, model, converter),
+                    Neutral = ExportExpression(vrmController.Vrm.Expression.Neutral, vrmController, model, converter),
                 },
                 Custom = vrmController.Vrm.Expression.CustomClips.ToDictionary(c => c.name, c => ExportExpression(c, vrmController, model, converter)),
             };

Assets/VRM10/Runtime/IO/Vrm10Importer.cs

@@ -421,20 +421,13 @@ namespace UniVRM10
                 vrm.Expression.LookDown = GetOrLoadExpression(ExpressionKey.LookDown.SubAssetKey, ExpressionPreset.lookDown, vrmExtension.Expressions?.Preset?.LookDown);
                 vrm.Expression.LookLeft = GetOrLoadExpression(ExpressionKey.LookLeft.SubAssetKey, ExpressionPreset.lookLeft, vrmExtension.Expressions?.Preset?.LookLeft);
                 vrm.Expression.LookRight = GetOrLoadExpression(ExpressionKey.LookRight.SubAssetKey, ExpressionPreset.lookRight, vrmExtension.Expressions?.Preset?.LookRight);
+                vrm.Expression.Neutral = GetOrLoadExpression(ExpressionKey.Neutral.SubAssetKey, ExpressionPreset.neutral, vrmExtension.Expressions?.Preset?.Neutral);
                 if (vrmExtension?.Expressions?.Custom != null)
                 {
                     foreach (var (name, expression) in vrmExtension.Expressions.Custom.Select(kv => (kv.Key, kv.Value)))
                     {
                         var key = ExpressionKey.CreateCustom(name);
                         var preset = ExpressionPreset.custom;
-                        if (preset == ExpressionPreset.custom && name == VRM10ObjectExpression.NEUTRAL_KEY)
-                        {
-                            // TODO:
-                            // 注意！JsonSchema の更新待ち？
-                            key = ExpressionKey.CreateFromPreset(ExpressionPreset.neutral);
-                            Debug.Log($"set neutral");
-                            preset = ExpressionPreset.neutral;
-                        }
                         var clip = GetOrLoadExpression(key.SubAssetKey, preset, expression);
                         if (clip != null)
                         {

Assets/VRM10/Runtime/Migration/MigrationVrm.cs

@@ -96,15 +96,11 @@ namespace UniVRM10
                             case ExpressionPreset.lookDown: SetIfNull(ref vrm1.Expressions.Preset.LookDown, expression); break;
                             case ExpressionPreset.lookLeft: SetIfNull(ref vrm1.Expressions.Preset.LookLeft, expression); break;
                             case ExpressionPreset.lookRight: SetIfNull(ref vrm1.Expressions.Preset.LookRight, expression); break;
-                            case ExpressionPreset.neutral:
-                                // TODO: 仕様確定待ち
-                                // Presetに格上げするか、小文字にする
-                                vrm1.Expressions.Custom[VRM10ObjectExpression.NEUTRAL_KEY] = expression;
-                                break;
+                            case ExpressionPreset.neutral: SetIfNull(ref vrm1.Expressions.Preset.Neutral, expression); break;
                             case ExpressionPreset.custom:
                                 if (vrm1.Expressions.Custom.ContainsKey(customName))
                                 {
-                                    // 同名が既存。不採用
+                                    // 同名が既存。先着を有効とする
                                 }
                                 else
                                 {

Assets/VRM10/Runtime/Migration/MigrationVrmExpression.cs

@@ -32,6 +32,7 @@ namespace UniVRM10
             switch (src)
             {
                 // https://github.com/vrm-c/vrm-specification/issues/185
+                // https://github.com/vrm-c/UniVRM/issues/1482
                 case "neutral": return ExpressionPreset.neutral;
 
                 case "a": return ExpressionPreset.aa;