MetallicRoughnessOcclusion テクスチャーの取り廻しを中心に改修

Assets/UniGLTF/Editor/UniGLTF/AssetTextureLoader.cs

@@ -8,10 +8,7 @@ public static class AssetTextureLoader
         public static Task<Texture2D> LoadTaskAsync(UnityPath m_assetPath,
             glTF gltf, int textureIndex)
         {
-            var textureType = TextureIO.GetglTFTextureType(gltf, textureIndex);
-            var colorSpace = TextureIO.GetColorSpace(textureType);
-            var isLinear = colorSpace == RenderTextureReadWrite.Linear;
-            var sampler = gltf.GetSamplerFromTextureIndex(textureIndex);
+            var colorSpace = gltf.GetColorSpace(textureIndex);
 
             //
             // texture from assets
@@ -25,7 +22,7 @@ public static Task<Texture2D> LoadTaskAsync(UnityPath m_assetPath,
             else
             {
                 importer.maxTextureSize = 8192;
-                importer.sRGBTexture = !isLinear;
+                importer.sRGBTexture = colorSpace == RenderTextureReadWrite.sRGB;
                 importer.SaveAndReimport();
             }
 
@@ -50,6 +47,7 @@ public static Task<Texture2D> LoadTaskAsync(UnityPath m_assetPath,
                 importer.SaveAndReimport();
             }
 
+            var sampler = gltf.GetSamplerFromTextureIndex(textureIndex);
             if (sampler != null)
             {
                 TextureSamplerUtil.SetSampler(Texture, sampler);

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/EditorMaterial.cs

@@ -25,8 +25,8 @@ public void Dispose()
             }
         }
 
-        static bool s_foldMaterials;
-        static bool s_foldTextures;
+        static bool s_foldMaterials = true;
+        static bool s_foldTextures = true;
 
         public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
         {
@@ -51,7 +51,17 @@ public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
             s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
             if (s_foldTextures)
             {
-                DrawRemapGUI<UnityEngine.Texture2D>(importer, GltfTextureEnumerator.Enumerate(parser.GLTF).Select(x => x.ConvertedName));
+                DrawRemapGUI<UnityEngine.Texture2D>(importer, GltfTextureEnumerator.Enumerate(parser.GLTF).Select(x =>
+                {
+                    switch (x.TextureType)
+                    {
+                        case GetTextureParam.TextureTypes.NormalMap:
+                            return x.GltflName;
+
+                        default:
+                            return x.ConvertedName;
+                    }
+                }));
             }
 
             if (GUILayout.Button("Clear"))

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/GlbScriptedImporter.cs

@@ -12,14 +12,7 @@ public class GlbScriptedImporter : ScriptedImporter
 
         public override void OnImportAsset(AssetImportContext ctx)
         {
-            try
-            {
-                ScriptedImporterImpl.Import(this, ctx, m_reverseAxis);
-            }
-            catch (System.Exception ex)
-            {
-                Debug.LogError(ex);
-            }
+            ScriptedImporterImpl.Import(this, ctx, m_reverseAxis);
         }
     }
 }

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/GltfScriptedImporter.cs

@@ -12,14 +12,7 @@ public class GltfScriptedImporter : ScriptedImporter
 
         public override void OnImportAsset(AssetImportContext ctx)
         {
-            try
-            {
-                ScriptedImporterImpl.Import(this, ctx, m_reverseAxis);
-            }
-            catch (System.Exception ex)
-            {
-                Debug.LogError(ex);
-            }
+            ScriptedImporterImpl.Import(this, ctx, m_reverseAxis);
         }
     }
 }

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/ScriptedImporterImpl.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
@@ -35,6 +36,12 @@ public static void Import(ScriptedImporter scriptedImporter, AssetImportContext
                 externalObjectMap.Where(x => x.Value != null).Select(x => (x.Value.name, x.Value)).Concat(
                 EnumerateTexturesFromUri(externalObjectMap, parser, UnityPath.FromUnityPath(scriptedImporter.assetPath).Parent))))
             {
+                // settings TextureImporters
+                foreach (var textureInfo in GltfTextureEnumerator.Enumerate(parser.GLTF))
+                {
+                    TextureImporterConfigurator.Configure(textureInfo, loaded.TextureFactory.ExternalMap);
+                }
+
                 loaded.InvertAxis = reverseAxis;
                 loaded.Load();
                 loaded.ShowMeshes();
@@ -64,8 +71,7 @@ public static void Import(ScriptedImporter scriptedImporter, AssetImportContext
             {
                 switch (texParam.TextureType)
                 {
-                    case GetTextureParam.METALLIC_GLOSS_PROP:
-                    case GetTextureParam.OCCLUSION_PROP:
+                    case GetTextureParam.TextureTypes.StandardMap:
                         break;
 
                     default:

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/TextureExtractor.cs

@@ -70,8 +70,7 @@ public void Extract(GetTextureParam param, bool hasUri)
 
                 switch (param.TextureType)
                 {
-                    case GetTextureParam.METALLIC_GLOSS_PROP:
-                    case GetTextureParam.OCCLUSION_PROP:
+                    case GetTextureParam.TextureTypes.StandardMap:
                         {
                             // write converted texture
                             targetPath = $"{m_path}/{param.ConvertedName}.png";
@@ -130,40 +129,13 @@ public static void ExtractTextures(string assetPath, TextureEnumerator textureEn
 
             EditorApplication.delayCall += () =>
             {
+                // Wait for the texture assets to be imported
+
                 foreach (var kv in extractor.Textures)
                 {
                     var targetPath = kv.Key;
                     var param = kv.Value;
 
-                    // TextureImporter                   
-                    var targetTextureImporter = AssetImporter.GetAtPath(targetPath) as TextureImporter;
-                    if (targetTextureImporter != null)
-                    {
-                        switch (param.TextureType)
-                        {
-                            case GetTextureParam.OCCLUSION_PROP:
-                            case GetTextureParam.METALLIC_GLOSS_PROP:
-#if VRM_DEVELOP
-                                Debug.Log($"{targetPath} => linear");
-#endif
-                                targetTextureImporter.sRGBTexture = false;
-                                targetTextureImporter.SaveAndReimport();
-                                break;
-
-                            case GetTextureParam.NORMAL_PROP:
-#if VRM_DEVELOP
-                                Debug.Log($"{targetPath} => normalmap");
-#endif
-                                targetTextureImporter.textureType = TextureImporterType.NormalMap;
-                                targetTextureImporter.SaveAndReimport();
-                                break;
-                        }
-                    }
-                    else
-                    {
-                        throw new FileNotFoundException(targetPath);
-                    }
-
                     // remap
                     var externalObject = AssetDatabase.LoadAssetAtPath<UnityEngine.Texture2D>(targetPath);
                     if (externalObject != null)

Assets/UniGLTF/Editor/UniGLTF/TextureImporterConfigurator.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UniGLTF
+{
+    public static class TextureImporterConfigurator
+    {
+        public static void ConfigureNormalMap(Texture2D texture)
+        {
+            var path = UnityPath.FromAsset(texture);
+            if (AssetImporter.GetAtPath(path.Value) is TextureImporter textureImporter)
+            {
+#if VRM_DEVELOP
+                Debug.Log($"{path} => normalmap");
+#endif
+                textureImporter.textureType = TextureImporterType.NormalMap;
+                textureImporter.SaveAndReimport();
+            }
+            else
+            {
+                throw new System.IO.FileNotFoundException($"{path}");
+            }
+        }
+
+        public static void ConfigureLinear(Texture2D texture)
+        {
+            var path = UnityPath.FromAsset(texture);
+            if (AssetImporter.GetAtPath(path.Value) is TextureImporter textureImporter)
+            {
+#if VRM_DEVELOP
+                Debug.Log($"{path} => linear");
+#endif
+                textureImporter.sRGBTexture = false;
+                textureImporter.SaveAndReimport();
+            }
+            else
+            {
+                throw new System.IO.FileNotFoundException($"{path}");
+            }
+        }
+
+        public static void Configure(GetTextureParam textureInfo, IDictionary<string, Texture2D> ExternalMap)
+        {
+            switch (textureInfo.TextureType)
+            {
+                case GetTextureParam.TextureTypes.NormalMap:
+                    {
+                        if (ExternalMap.TryGetValue(textureInfo.GltflName, out Texture2D external))
+                        {
+                            ConfigureNormalMap(external);
+                        }
+                    }
+                    break;
+
+                case GetTextureParam.TextureTypes.StandardMap:
+                    {
+                        if (ExternalMap.TryGetValue(textureInfo.ConvertedName, out Texture2D external))
+                        {
+                            ConfigureLinear(external);
+                        }
+                    }
+                    break;
+
+                case GetTextureParam.TextureTypes.sRGB:
+                    break;
+
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+    }
+}

Assets/UniGLTF/Runtime/UniGLTF/Format/glTFMaterial.cs

@@ -5,12 +5,10 @@ namespace UniGLTF
 {
     public enum glTFTextureTypes
     {
-        BaseColor,
-        Metallic,
+        OcclusionMetallicRoughness,
         Normal,
-        Occlusion,
-        Emissive,
-        Unknown
+        SRGB,
+        Linear,
     }
 
     public interface IglTFTextureinfo
@@ -38,19 +36,13 @@ public abstract class glTFTextureInfo : IglTFTextureinfo
     [Serializable]
     public class glTFMaterialBaseColorTextureInfo : glTFTextureInfo
     {
-        public override glTFTextureTypes TextureType
-        {
-            get { return glTFTextureTypes.BaseColor; }
-        }
+        public override glTFTextureTypes TextureType => glTFTextureTypes.SRGB;
     }
 
     [Serializable]
     public class glTFMaterialMetallicRoughnessTextureInfo : glTFTextureInfo
     {
-        public override glTFTextureTypes TextureType
-        {
-            get { return glTFTextureTypes.Metallic; }
-        }
+        public override glTFTextureTypes TextureType => glTFTextureTypes.OcclusionMetallicRoughness;
     }
 
     [Serializable]
@@ -70,19 +62,13 @@ public class glTFMaterialOcclusionTextureInfo : glTFTextureInfo
         [JsonSchema(Minimum = 0.0, Maximum = 1.0)]
         public float strength = 1.0f;
 
-        public override glTFTextureTypes TextureType
-        {
-            get { return glTFTextureTypes.Occlusion; }
-        }
+        public override glTFTextureTypes TextureType => glTFTextureTypes.OcclusionMetallicRoughness;
     }
 
     [Serializable]
     public class glTFMaterialEmissiveTextureInfo : glTFTextureInfo
     {
-        public override glTFTextureTypes TextureType
-        {
-            get { return glTFTextureTypes.Emissive; }
-        }
+        public override glTFTextureTypes TextureType => glTFTextureTypes.SRGB;
     }
 
     [Serializable]

Assets/UniGLTF/Runtime/UniGLTF/IO/ImporterContext.cs

@@ -56,6 +56,7 @@ public ImporterContext(GltfParser parser,
                 };
 #endif
             }
+
             m_textureFactory = new TextureFactory(loadTextureAsync, externalObjectMap);
             m_materialFactory = new MaterialFactory(GLTF, Storage, externalObjectMap);
         }