vrm1のローダー更新

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

@@ -34,14 +34,14 @@ public void Dispose()
         static bool s_foldMaterials = true;
         static bool s_foldTextures = true;
 
-        public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
+        public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures)
         {
             var canExtract = !importer.GetExternalObjectMap().Any(x => x.Value is Material || x.Value is Texture2D);
             using (new TmpGuiEnable(canExtract))
             {
                 if (GUILayout.Button("Extract Materials And Textures ..."))
                 {
-                    ExtractMaterialsAndTextures(importer, parser);
+                    ExtractMaterialsAndTextures(importer, parser, enumTextures);
                 }
             }
 
@@ -57,7 +57,7 @@ public static void OnGUIMaterial(ScriptedImporter importer, GltfParser parser)
             s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
             if (s_foldTextures)
             {
-                var names = GltfTextureEnumerator.Enumerate(parser)
+                var names = enumTextures(parser)
                     .Select(x =>
                     {
                         if (x.TextureType != TextureImportTypes.StandardMap && !string.IsNullOrEmpty(x.Uri))
@@ -122,7 +122,7 @@ public static void SetExternalUnityObject<T>(this ScriptedImporter self, UnityEd
             AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
         }
 
-        static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser)
+        static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures)
         {
             if (string.IsNullOrEmpty(self.assetPath))
             {
@@ -143,7 +143,7 @@ static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser
             var assetPath = UnityPath.FromFullpath(parser.TargetPath);
             var dirName = $"{assetPath.FileNameWithoutExtension}.Textures";
             TextureExtractor.ExtractTextures(parser, assetPath.Parent.Child(dirName),
-                GltfTextureEnumerator.Enumerate,
+                enumTextures,
                 self.GetSubAssets<UnityEngine.Texture2D>(self.assetPath).ToArray(),
                 addRemap,
                 onCompleted

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/GlbScriptedImporterEditorGUI.cs

@@ -48,7 +48,7 @@ public override void OnInspectorGUI()
                     break;
 
                 case Tabs.Materials:
-                    EditorMaterial.OnGUIMaterial(m_importer, m_parser);
+                    EditorMaterial.OnGUIMaterial(m_importer, m_parser, GltfTextureEnumerator.EnumerateAllTexturesDistinct);
                     break;
             }
         }

Assets/UniGLTF/Editor/UniGLTF/ScriptedImporter/GltfScriptedImporterEditorGUI.cs

@@ -48,7 +48,7 @@ public override void OnInspectorGUI()
                     break;
 
                 case Tabs.Materials:
-                    EditorMaterial.OnGUIMaterial(m_importer, m_parser);
+                    EditorMaterial.OnGUIMaterial(m_importer, m_parser, GltfTextureEnumerator.EnumerateAllTexturesDistinct);
                     break;
             }
         }

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

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
@@ -37,32 +36,28 @@ public static void Import(ScriptedImporter scriptedImporter, AssetImportContext
             // Import(create unity objects)
             //
             var externalObjectMap = scriptedImporter.GetExternalObjectMap().Select(kv => (kv.Value.name, kv.Value)).ToArray();
-            
+
             var externalTextures = EnumerateTexturesFromUri(externalObjectMap, parser, UnityPath.FromUnityPath(scriptedImporter.assetPath).Parent).ToArray();
 
-            using (var loaded = new ImporterContext(parser, externalObjectMap.Concat(externalTextures)))
+            using (var loader = new ImporterContext(parser, externalObjectMap.Concat(externalTextures)))
             {
                 // settings TextureImporters
-                foreach (var textureInfo in GltfTextureEnumerator.Enumerate(parser))
+                foreach (var textureInfo in GltfTextureEnumerator.EnumerateAllTexturesDistinct(parser))
                 {
-                    TextureImporterConfigurator.Configure(textureInfo, loaded.TextureFactory.ExternalMap);
+                    TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalMap);
                 }
 
-                loaded.InvertAxis = reverseAxis;
-                loaded.Load();
-                loaded.ShowMeshes();
+                loader.InvertAxis = reverseAxis;
+                loader.Load();
+                loader.ShowMeshes();
 
-                loaded.TransferOwnership(o =>
+                loader.TransferOwnership(o =>
                 {
-#if VRM_DEVELOP
-                    Debug.Log($"[{o.GetType().Name}] {o.name} will not destroy");
-#endif
-
                     context.AddObjectToAsset(o.name, o);
                     if (o is GameObject)
                     {
                         // Root GameObject is main object
-                        context.SetMainObject(loaded.Root);
+                        context.SetMainObject(loader.Root);
                     }
 
                     return true;
@@ -74,7 +69,7 @@ public static void Import(ScriptedImporter scriptedImporter, AssetImportContext
             GltfParser parser, UnityPath dir)
         {
             var used = new HashSet<Texture2D>();
-            foreach (var texParam in GltfTextureEnumerator.Enumerate(parser))
+            foreach (var texParam in GltfTextureEnumerator.EnumerateAllTexturesDistinct(parser))
             {
                 switch (texParam.TextureType)
                 {
@@ -96,8 +91,10 @@ public static void Import(ScriptedImporter scriptedImporter, AssetImportContext
                                 {
                                     // exclude. skip
                                 }
-                                else{
-                                    if(used.Add(asset)){
+                                else
+                                {
+                                    if (used.Add(asset))
+                                    {
                                         yield return (asset.name, asset);
                                     }
                                 }

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

@@ -102,7 +102,7 @@ public static DirectoryInfo SafeCreateDirectory(string path)
         /// <param name="dirName"></param>
         /// <param name="onCompleted"></param>
         public static void ExtractTextures(GltfParser parser, UnityPath textureDirectory,
-            TextureEnumerator textureEnumerator, Texture2D[] subAssets, Action<Texture2D> addRemap,
+            EnumerateAllTexturesDistinctFunc textureEnumerator, Texture2D[] subAssets, Action<Texture2D> addRemap,
             Action<IEnumerable<UnityPath>> onCompleted = null)
         {
             var extractor = new TextureExtractor(parser, textureDirectory, subAssets);

Assets/UniGLTF/Runtime/Extensions/glTFExtensions.cs

@@ -476,5 +476,51 @@ public static (string, List<glTFBuffer>) ToGltf(this glTF self, string gltfPath)
             self.RemoveUnusedExtensions(json);
             return (json, self.buffers);
         }
+
+        public static bool IsGeneratedUniGLTFAndOlderThan(string generatorVersion, int major, int minor)
+        {
+            if (string.IsNullOrEmpty(generatorVersion)) return false;
+            if (generatorVersion == "UniGLTF") return true;
+            if (!generatorVersion.FastStartsWith("UniGLTF-")) return false;
+
+            try
+            {
+                var splitted = generatorVersion.Substring(8).Split('.');
+                var generatorMajor = int.Parse(splitted[0]);
+                var generatorMinor = int.Parse(splitted[1]);
+
+                if (generatorMajor < major)
+                {
+                    return true;
+                }
+                else if (generatorMajor > major)
+                {
+                    return false;
+                }
+                else
+                {
+                    if (generatorMinor >= minor)
+                    {
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarningFormat("{0}: {1}", generatorVersion, ex);
+                return false;
+            }
+        }
+
+        public static bool IsGeneratedUniGLTFAndOlder(this glTF gltf, int major, int minor)
+        {
+            if (gltf == null) return false;
+            if (gltf.asset == null) return false;
+            return IsGeneratedUniGLTFAndOlderThan(gltf.asset.generator, major, minor);
+        }
     }
 }

Assets/UniGLTF/Runtime/UniGLTF/Format/ArraySegmentByteBuffer.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 
 
 namespace UniGLTF
@@ -27,9 +26,11 @@ public glTFBufferView Extend<T>(ArraySegment<T> array, glBufferTarget target) wh
             throw new NotImplementedException();
         }
 
-        public ArraySegment<byte> GetBytes()
+        public void ExtendCapacity(int capacity)
         {
-            return m_bytes;
+            throw new NotImplementedException();
         }
+
+        public ArraySegment<byte> Bytes => m_bytes;
     }
 }

Assets/UniGLTF/Runtime/UniGLTF/Format/IBytesBuffer.cs

@@ -5,7 +5,8 @@ namespace UniGLTF
     public interface IBytesBuffer
     {
         string Uri { get; }
-        ArraySegment<Byte> GetBytes();
-        glTFBufferView Extend<T>(ArraySegment<T> array, glBufferTarget target) where T : struct;
+        ArraySegment<Byte> Bytes { get; }
+        glTFBufferView Extend<T>(ArraySegment<T> array, glBufferTarget target = glBufferTarget.NONE) where T : struct;
+        void ExtendCapacity(int capacity);
     }
 }

Assets/UniGLTF/Runtime/UniGLTF/Format/glTFBuffer.cs

@@ -6,11 +6,12 @@ namespace UniGLTF
     [Serializable]
     public class glTFBuffer
     {
-        IBytesBuffer Storage;
+        IBytesBuffer m_buffer;
+        public IBytesBuffer Buffer => m_buffer;
 
         public void OpenStorage(IStorage storage)
         {
-            Storage = new ArraySegmentByteBuffer(storage.Get(uri));
+            m_buffer = new ArraySegmentByteBuffer(storage.Get(uri));
         }
 
         public glTFBuffer()
@@ -20,7 +21,7 @@ public glTFBuffer()
 
         public glTFBuffer(IBytesBuffer storage)
         {
-            Storage = storage;
+            m_buffer = storage;
         }
 
         public string uri;
@@ -39,14 +40,14 @@ public glTFBufferView Append<T>(T[] array, glBufferTarget target) where T : stru
         }
         public glTFBufferView Append<T>(ArraySegment<T> segment, glBufferTarget target) where T : struct
         {
-            var view = Storage.Extend(segment, target);
-            byteLength = Storage.GetBytes().Count;
+            var view = m_buffer.Extend(segment, target);
+            byteLength = m_buffer.Bytes.Count;
             return view;
         }
 
         public ArraySegment<Byte> GetBytes()
         {
-            return Storage.GetBytes();
+            return m_buffer.Bytes;
         }
     }
 

Assets/UniGLTF/Runtime/UniGLTF/IO/ArrayByteBuffer.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace UniGLTF
+{
+    /// <summary>
+    /// for exporter
+    /// </summary>
+    public class ArrayByteBuffer : IBytesBuffer
+    {
+        public string Uri
+        {
+            get;
+            private set;
+        }
+
+        Byte[] m_bytes;
+        int m_used;
+
+        public ArrayByteBuffer(Byte[] bytes = null)
+        {
+            Uri = "";
+            m_bytes = bytes;
+        }
+
+        public glTFBufferView Extend<T>(ArraySegment<T> array, glBufferTarget target) where T : struct
+        {
+            using (var pin = Pin.Create(array))
+            {
+                var elementSize = Marshal.SizeOf(typeof(T));
+                var view = Extend(pin.Ptr, array.Count * elementSize, elementSize, target);
+                return view;
+            }
+        }
+
+        public glTFBufferView Extend(IntPtr p, int bytesLength, int stride, glBufferTarget target)
+        {
+            var tmp = m_bytes;
+            // alignment
+            var padding = m_used % stride == 0 ? 0 : stride - m_used % stride;
+
+            if (m_bytes == null || m_used + padding + bytesLength > m_bytes.Length)
+            {
+                // recreate buffer
+                m_bytes = new Byte[m_used + padding + bytesLength];
+                if (m_used > 0)
+                {
+                    Buffer.BlockCopy(tmp, 0, m_bytes, 0, m_used);
+                }
+            }
+            if (m_used + padding + bytesLength > m_bytes.Length)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+
+            Marshal.Copy(p, m_bytes, m_used + padding, bytesLength);
+            var result = new glTFBufferView
+            {
+                buffer = 0,
+                byteLength = bytesLength,
+                byteOffset = m_used + padding,
+                byteStride = stride,
+                target = target,
+            };
+            m_used = m_used + padding + bytesLength;
+            return result;
+        }
+
+        public void ExtendCapacity(int capacity)
+        {
+            if (m_bytes != null && capacity < m_bytes.Length)
+            {
+                return;
+            }
+
+            var newBuffer = new byte[capacity];
+            if (m_bytes != null && m_used > 0)
+            {
+                Buffer.BlockCopy(m_bytes, 0, newBuffer, 0, m_used);
+            }
+            m_bytes = newBuffer;
+        }
+
+        public ArraySegment<byte> Bytes
+        {
+            get
+            {
+                if (m_bytes == null)
+                {
+                    return new ArraySegment<byte>();
+                }
+
+                return new ArraySegment<byte>(m_bytes, 0, m_used);
+            }
+        }
+    }
+}