/// <summary>
        ///
        /// * Texture(.png etc...)をディスクに書き出す
        /// * EditorApplication.delayCall で処理を進めて 書き出した画像が Asset として成立するのを待つ
        /// * 書き出した Asset から TextureImporter を取得して設定する
        ///
        /// </summary>
        /// <param name="importer"></param>
        /// <param name="dirName"></param>
        /// <param name="onCompleted"></param>
        public static void ExtractTextures(GltfParser parser, UnityPath textureDirectory,
                                           EnumerateAllTexturesDistinctFunc textureEnumerator, Texture2D[] subAssets, Action <Texture2D> addRemap,
                                           Action <IEnumerable <UnityPath> > onCompleted = null)
        {
            var extractor = new TextureExtractor(parser, textureDirectory, subAssets);

            foreach (var x in textureEnumerator(parser))
            {
                extractor.Extract(x);
            }

            EditorApplication.delayCall += () =>
            {
                // Wait for the texture assets to be imported

                foreach (var kv in extractor.Textures)
                {
                    var targetPath = kv.Key;
                    var param      = kv.Value;

                    // remap
                    var externalObject = targetPath.LoadAsset <Texture2D>();
                    if (externalObject != null)
                    {
                        addRemap(externalObject);
                    }
                }

                if (onCompleted != null)
                {
                    onCompleted(extractor.Textures.Keys);
                }
            };
        }
Exemple #2
0
        public static void OnGUI(ScriptedImporter importer, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures)
        {
            var hasExternal = importer.GetExternalObjectMap().Any(x => x.Value is Material || x.Value is Texture2D);

            using (new TmpGuiEnable(!hasExternal))
            {
                if (GUILayout.Button("Extract Materials And Textures ..."))
                {
                    ExtractMaterialsAndTextures(importer, parser, enumTextures);
                }
            }

            //
            // Draw ExternalObjectMap
            //
            s_foldMaterials = EditorGUILayout.Foldout(s_foldMaterials, "Remapped Materials");
            if (s_foldMaterials)
            {
                importer.DrawRemapGUI <UnityEngine.Material>(parser.GLTF.materials.Select(x => x.name));
            }

            s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
            if (s_foldTextures)
            {
                var names = enumTextures(parser)
                            .Select(x =>
                {
                    if (x.TextureType != TextureImportTypes.StandardMap && !string.IsNullOrEmpty(x.Uri))
                    {
                        // GLTF の 無変換テクスチャーをスキップする
                        return(null);
                    }

                    switch (x.TextureType)
                    {
                    case TextureImportTypes.NormalMap:
                        return(x.GltfName);

                    default:
                        return(x.ConvertedName);
                    }
                })
                            .Where(x => !string.IsNullOrEmpty(x))
                ;
                importer.DrawRemapGUI <UnityEngine.Texture2D>(names);
            }

            if (GUILayout.Button("Clear"))
            {
                importer.ClearExternalObjects <UnityEngine.Material>();
                importer.ClearExternalObjects <UnityEngine.Texture2D>();
            }
        }
Exemple #3
0
        public static void OnGUI(ScriptedImporter importer, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures)
        {
            var hasExternal = importer.GetExternalObjectMap().Any(x => x.Value is Material || x.Value is Texture2D);

            using (new TmpGuiEnable(!hasExternal))
            {
                if (GUILayout.Button("Extract Materials And Textures ..."))
                {
                    ExtractMaterialsAndTextures(importer, parser, enumTextures);
                }
            }

            //
            // Draw ExternalObjectMap
            //
            s_foldMaterials = EditorGUILayout.Foldout(s_foldMaterials, "Remapped Materials");
            if (s_foldMaterials)
            {
                importer.DrawRemapGUI <UnityEngine.Material>(parser.GLTF.materials.Select(x => new SubAssetKey(typeof(Material), x.name)));
            }

            s_foldTextures = EditorGUILayout.Foldout(s_foldTextures, "Remapped Textures");
            if (s_foldTextures)
            {
                importer.DrawRemapGUI <UnityEngine.Texture2D>(enumTextures(parser)
                                                              .Where(x =>
                {
                    var(key, param) = x;
                    if ((param.TextureType == TextureImportTypes.sRGB || param.TextureType == TextureImportTypes.NormalMap) && !string.IsNullOrEmpty(param.Uri))
                    {
                        // GLTF の 無変換テクスチャーをスキップする
                        return(false);
                    }
                    return(true);
                })
                                                              .Select(x => x.Key)
                                                              );
            }

            if (GUILayout.Button("Clear"))
            {
                importer.ClearExternalObjects <UnityEngine.Material>();
                importer.ClearExternalObjects <UnityEngine.Texture2D>();
            }
        }
Exemple #4
0
        static void ExtractMaterialsAndTextures(ScriptedImporter self, GltfParser parser, EnumerateAllTexturesDistinctFunc enumTextures)
        {
            if (string.IsNullOrEmpty(self.assetPath))
            {
                return;
            }

            Action <SubAssetKey, Texture2D> addRemap = (key, externalObject) =>
            {
                self.AddRemap(new AssetImporter.SourceAssetIdentifier(key.Type, key.Name), externalObject);
            };
            Action <IEnumerable <UnityPath> > onCompleted = _ =>
            {
                AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
                self.ExtractMaterials();
                AssetDatabase.ImportAsset(self.assetPath, ImportAssetOptions.ForceUpdate);
            };

            var assetPath = UnityPath.FromFullpath(parser.TargetPath);
            var dirName   = $"{assetPath.FileNameWithoutExtension}.Textures";

            TextureExtractor.ExtractTextures(parser, assetPath.Parent.Child(dirName),
                                             enumTextures,
                                             self.GetSubAssets <UnityEngine.Texture2D>(self.assetPath).ToArray(),
                                             addRemap,
                                             onCompleted
                                             );
        }