Exemple #1
0
        GameObject LoadGltf(List <string> warnings)
        {
            // This is intended to be identical to using GltfModelBuilder, except synchronous.
            GameObject go;
            bool       fromPoly      = (m_Location.GetLocationType() == Location.Type.PolyAssetId);
            string     localPath     = m_Location.AbsolutePath;
            string     assetLocation = Path.GetDirectoryName(localPath);
            // Synchronous, so don't use slow image loading
            var loader = new TiltBrushUriLoader(localPath, assetLocation, loadImages: false);

            try
            {
                ImportGltf.GltfImportResult result = ImportGltf.Import(
                    localPath, loader,
                    new ImportMaterialCollector(assetLocation, uniqueSeed: localPath),
                    fromPoly ? kPolyGltfImportOptions : kGltfImportOptions);
                go = result.root;
                m_ImportMaterialCollector = (ImportMaterialCollector)result.materialCollector;
            }
            catch (Exception ex)
            {
                m_LoadError   = new LoadError("Invalid data", ex.Message);
                go            = null;
                m_AllowExport = false;
                Debug.LogException(ex);
            }

            m_AllowExport = (go != null);
            return(go);
        }
Exemple #2
0
        private static GameObject DoImport(string gltfPath, PolyImportOptions options, bool savePrefab = false)
        {
            var text = File.ReadAllText(gltfPath);

            GltfSchemaVersion version;

            if (text.Contains("\"version\": \"1"))
            {
                version = GltfSchemaVersion.GLTF1;
            }
            else if (text.Contains("\"version\": \"2"))
            {
                version = GltfSchemaVersion.GLTF2;
            }
            else
            {
                // well, just guess I suppose... it's just test code
                version = GltfSchemaVersion.GLTF1;
            }

            Debug.LogFormat("Import {0} as {1}", gltfPath, version);
            IUriLoader binLoader = new BufferedStreamLoader(Path.GetDirectoryName(gltfPath));

            using (TextReader reader = new StreamReader(gltfPath)) {
                var result = ImportGltf.Import(version, reader, binLoader, options);
                if (savePrefab)
                {
                    SaveAsSinglePrefab(result, Path.ChangeExtension(gltfPath, ".prefab"));
                }
                return(result.root);
            }
        }
Exemple #3
0
        public override void OnImportAsset(AssetImportContext ctx)
        {
            IUriLoader loader = new BufferedStreamLoader(
                ctx.assetPath, Path.GetDirectoryName(ctx.assetPath));

            ImportGltf.GltfImportResult result = ImportGltf.Import(
                ctx.assetPath, loader, null, kOptions);

            // The "identifier" param passed here is supposed to be:
            // - Unique to this asset
            // - Deterministic (if possible)
            foreach (var obj in result.textures)
            {
                if (!AssetDatabase.Contains(obj))
                {
                    ctx.AddObjectToAsset("Texture/" + obj.name, obj);
                }
            }
            foreach (var obj in result.materials)
            {
                ctx.AddObjectToAsset("Material/" + obj.name, obj);
            }
            foreach (var obj in result.meshes)
            {
                ctx.AddObjectToAsset("Mesh/" + obj.name, obj);
            }
            string objectName = Path.GetFileNameWithoutExtension(ctx.assetPath);

            result.root.name = objectName;
            ctx.AddObjectToAsset("ROOT", result.root);
            ctx.SetMainObject(result.root);
        }
Exemple #4
0
/*
 * public override void OnImportAsset(AssetImportContext ctx) {
 *  IUriLoader loader = new BufferedStreamLoader(
 *      ctx.assetPath, Path.GetDirectoryName(ctx.assetPath));
 *
 *  ImportGltf.GltfImportResult result = ImportGltf.Import(
 *      ctx.assetPath, loader, null, kOptions);
 *
 *  // The "identifier" param passed here is supposed to be:
 *  // - Unique to this asset
 *  // - Deterministic (if possible)
 *  foreach (var obj in result.textures) {
 *    if (! AssetDatabase.Contains(obj)) {
 *      ctx.AddObjectToAsset("Texture/" + obj.name, obj);
 *    }
 *  }
 *  foreach (var obj in result.materials) {
 *    ctx.AddObjectToAsset("Material/" + obj.name, obj);
 *  }
 *  foreach (var obj in result.meshes) {
 *    ctx.AddObjectToAsset("Mesh/" + obj.name, obj);
 *  }
 *  string objectName = Path.GetFileNameWithoutExtension(ctx.assetPath);
 *  result.root.name = objectName;
 *  ctx.AddObjectToAsset("ROOT", result.root);
 *  ctx.SetMainObject(result.root);
 * }
 */


        public static GameObject ImportTiltBrushAsset(string path)
        {
            IUriLoader loader = new BufferedStreamLoader(
                path, Path.GetDirectoryName(path));//Directory.GetParent(path).ToString());


            ImportGltf.GltfImportResult result = ImportGltf.Import(
                path, loader, null, kOptions);

            return(result.root);
        }
        public static void TestSaveAsSinglePrefab()
        {
            IUriLoader binLoader = new BufferedStreamLoader(Path.GetDirectoryName(Path.Combine(RepoRoot, kMoto)));

            ImportGltf.GltfImportResult result = null;
            using (TextReader reader = new StreamReader(Path.Combine(RepoRoot, kMoto))) {
                result = ImportGltf.Import(GltfSchemaVersion.GLTF1, reader, binLoader, PolyImportOptions.Default());
            }
            string prefabPath = "Assets/Poly/TestData/single_p.prefab";

            SaveAsSinglePrefab(result, prefabPath);
            GameObject.DestroyImmediate(result.root);
        }
        public static void TestSaveAsSeparateWithMeshesInAsset()
        {
            IUriLoader binLoader = new BufferedStreamLoader(Path.GetDirectoryName(Path.Combine(RepoRoot, kAllBrush10)));

            ImportGltf.GltfImportResult result = null;
            using (TextReader reader = new StreamReader(Path.Combine(RepoRoot, kAllBrush10))) {
                result = ImportGltf.Import(GltfSchemaVersion.GLTF1, reader, binLoader, PolyImportOptions.Default());
            }
            string assetPath  = "Assets/Poly/TestData/separate_a.asset";
            string prefabPath = "Assets/Poly/TestData/separate_p.prefab";

            SaveAsSeparateWithMeshesInAsset(result, assetPath, prefabPath);
            GameObject.DestroyImmediate(result.root);
        }
        /// <summary>
        /// Executes the given import request, producing a PtAsset and a prefab.
        /// </summary>
        /// <param name="request">The request to perform.</param>
        private static void ExecuteImportRequest(ImportRequest request)
        {
            PtDebug.LogFormat("Executing import request: {0}", request);

            string gltfFullPath   = PtUtils.ToAbsolutePath(request.gltfLocalPath);
            string assetLocalPath = request.ptAssetLocalPath;
            string assetFullPath  = PtUtils.ToAbsolutePath(assetLocalPath);

            PtAsset assetToReplace = AssetDatabase.LoadAssetAtPath <PtAsset>(assetLocalPath);

            GameObject prefabToReplace = null;

            if (assetToReplace != null)
            {
                if (assetToReplace.assetPrefab == null)
                {
                    Debug.LogErrorFormat("Couldn't find prefab for asset {0}.", assetToReplace);
                    PtAnalytics.SendEvent(PtAnalytics.Action.IMPORT_FAILED, "Prefab not found");
                    return;
                }
                prefabToReplace = assetToReplace.assetPrefab;
            }

            // Determine if file is glTF2 or glTF1.
            bool isGltf2 = Path.GetExtension(request.gltfLocalPath) == ".gltf2";

            // First, import the GLTF and build a GameObject from it.
            EditorUtility.DisplayProgressBar(PROGRESS_BAR_TITLE, PROGRESS_BAR_TEXT, 0.5f);
            // Use a SanitizedPath stream loader because any format file we have downloaded and saved to disk we
            // have replaced the original relative path string with the MD5 string hash. This custom stream loader
            // will always convert uris passed to it to this hash value, and read them from there.
            IUriLoader binLoader = new HashedPathBufferedStreamLoader(Path.GetDirectoryName(gltfFullPath));

            ImportGltf.GltfImportResult result = null;
            using (TextReader reader = new StreamReader(gltfFullPath)) {
                result = ImportGltf.Import(isGltf2 ? GltfSchemaVersion.GLTF2 : GltfSchemaVersion.GLTF1,
                                           reader, binLoader, request.options.baseOptions);
            }
            EditorUtility.ClearProgressBar();
            string baseName = PtUtils.GetPtAssetBaseName(request.polyAsset);

            result.root.name = baseName;

            // Create the asset (delete it first if it exists).
            if (File.Exists(assetFullPath))
            {
                AssetDatabase.DeleteAsset(assetLocalPath);

                // If we are replacing an existing asset, we should rename the replacement to the new name,
                // since the name reflects the identity of the asset. So if the user is importing the asset
                // dog_a381b3g to replace what was previously cat_v81938.asset, the replacement file should
                // be named dog_a381b3g.asset, not cat_v81938.asset.
                assetLocalPath = PtUtils.GetDefaultPtAssetPath(request.polyAsset);
                assetFullPath  = PtUtils.ToAbsolutePath(assetLocalPath);
            }
            Directory.CreateDirectory(Path.GetDirectoryName(assetFullPath));

            // Create the new PtAsset and fill it in.
            AssetDatabase.CreateAsset(ScriptableObject.CreateInstance <PtAsset>(), assetLocalPath);
            PtAsset newAsset = AssetDatabase.LoadAssetAtPath <PtAsset>(assetLocalPath);

            newAsset.name    = baseName;
            newAsset.title   = request.polyAsset.displayName ?? "";
            newAsset.author  = request.polyAsset.authorName ?? "";
            newAsset.license = request.polyAsset.license;
            newAsset.url     = request.polyAsset.Url;

            // Ensure the imported object has a PtAssetObject component which references the PtAsset.
            result.root.AddComponent <PtAssetObject>().asset = newAsset;

            // Add all the meshes to the PtAsset.
            SaveMeshes(result.meshes, newAsset);

            // If the asset has materials, save those to the PtAsset.
            if (result.materials != null)
            {
                SaveMaterials(result.materials, newAsset);
            }

            // If the asset has textures, save those to the PtAsset.
            if (result.textures != null)
            {
                SaveTextures(result.textures, newAsset);
            }

            // Reimport is required to ensure custom asset displays correctly.
            AssetDatabase.ImportAsset(assetLocalPath);

            GameObject newPrefab;

            if (prefabToReplace)
            {
                // Replace the existing prefab with our new object, without breaking prefab connections.
                newPrefab = PrefabUtility.ReplacePrefab(result.root, prefabToReplace, ReplacePrefabOptions.ReplaceNameBased);
                AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(newPrefab), baseName);
            }
            else
            {
                // Create a new prefab.
                // Prefab path is the same as the asset path but with the extension changed to '.prefab'.
                string prefabLocalPath = Regex.Replace(assetLocalPath, "\\.asset$", ".prefab");
                if (!prefabLocalPath.EndsWith(".prefab"))
                {
                    Debug.LogErrorFormat("Error: failed to compute prefab path for {0}", assetLocalPath);
                    PtAnalytics.SendEvent(PtAnalytics.Action.IMPORT_FAILED, "Prefab path error");
                    return;
                }
                newPrefab = PrefabUtility.CreatePrefab(prefabLocalPath, result.root);
            }

            // Now ensure the asset points to the prefab.
            newAsset.assetPrefab = newPrefab;
            if (newAsset.assetPrefab == null)
            {
                Debug.LogErrorFormat("Could not get asset prefab reference for asset {0}", newAsset);
                PtAnalytics.SendEvent(PtAnalytics.Action.IMPORT_FAILED, "Prefab ref error");
            }

            GameObject.DestroyImmediate(result.root);

            AssetDatabase.Refresh();

            if (request.options.alsoInstantiate)
            {
                PrefabUtility.InstantiatePrefab(newPrefab);
            }

            PtDebug.LogFormat("GLTF import complete: {0}", request);

            PtAnalytics.SendEvent(PtAnalytics.Action.IMPORT_SUCCESSFUL, isGltf2 ? "GLTF2" : "GLTF1");

            // If this is a third-party asset, we need to update the attributions file.
            AttributionFileGenerator.Generate(/* showUi */ false);

            EditorWindow.GetWindow <AssetBrowserWindow>().HandleAssetImported(request.polyAsset.name);

            // Select the prefab in the editor so the user knows where it is.
            AssetDatabase.Refresh();
            Selection.activeObject = newPrefab;
            EditorGUIUtility.PingObject(newPrefab);
        }