public void TextureExtractTest() { var path = GetGltfTestModelPath("BoomBox.glb"); if (path == null) { return; } // parse var parser = new GltfParser(); parser.ParsePath(path.FullName); // load var loader = new ImporterContext(parser); loader.Load(); // extractor var extractor = new TextureExtractor(parser, UnityPath.FromUnityPath(""), loader.TextureFactory.Textures.Select(x => (new SubAssetKey(typeof(Texture2D), x.Texture.name), x.Texture)).ToArray()); var m = GltfTextureEnumerator.EnumerateTexturesReferencedByMaterials(parser, 0).FirstOrDefault(x => x.Item1.Name == "texture_1.standard"); Assert.Catch <NotImplementedException>(() => extractor.Extract(m.Item1, m.Item2)); }
static void ImportDelayed(string src, UnityPath prefabPath, ImporterContext context) { EditorApplication.delayCall += () => { // // After textures imported(To ensure TextureImporter be accessible). // try { context.Load(); context.SaveAsAsset(prefabPath); context.EditorDestroyRoot(); } catch (UniGLTFNotSupportedException ex) { Debug.LogWarningFormat("{0}: {1}", src, ex.Message ); context.EditorDestroyRootAndAssets(); } catch (Exception ex) { Debug.LogErrorFormat("import error: {0}", src); Debug.LogErrorFormat("{0}", ex); context.EditorDestroyRootAndAssets(); } }; }
public void UniGLTFSimpleSceneTest() { var go = CreateSimpelScene(); var context = new ImporterContext(); try { // export var gltf = new glTF(); using (var exporter = new gltfExporter(gltf)) { exporter.Prepare(go); exporter.Export(); // import context.ParseJson(gltf.ToJson(), new SimpleStorage(new ArraySegment <byte>())); //Debug.LogFormat("{0}", context.Json); context.Load(); AssertAreEqual(go.transform, context.Root.transform); } } finally { //Debug.LogFormat("Destory, {0}", go.name); GameObject.DestroyImmediate(go); context.Destroy(true); } }
public void UniGLTFSimpleSceneTest() { var go = CreateSimpleScene(); // export var gltf = new glTF(); string json = null; using (var exporter = new gltfExporter(gltf, new GltfExportSettings())) { exporter.Prepare(go); exporter.Export(new GltfExportSettings(), new EditorTextureSerializer()); // remove empty buffer gltf.buffers.Clear(); json = gltf.ToJson(); } // parse var data = new JsonWithStorageParser(json).Parse(); // import using (var context = new ImporterContext(data)) using (var loaded = context.Load()) { AssertAreEqual(go.transform, loaded.transform); } }
public void UniGLTFSimpleSceneTest() { var go = CreateSimpleScene(); // export var gltf = new glTF(); string json = null; using (var exporter = new gltfExporter(gltf)) { exporter.Prepare(go); exporter.Export(MeshExportSettings.Default, AssetTextureUtil.IsTextureEditorAsset, AssetTextureUtil.GetTextureBytesWithMime); // remove empty buffer gltf.buffers.Clear(); json = gltf.ToJson(); } // parse var parser = new GltfParser(); parser.ParseJson(json, new SimpleStorage(new ArraySegment <byte>())); // import using (var context = new ImporterContext(parser)) { context.Load(); AssertAreEqual(go.transform, context.Root.transform); } }
static void RuntimeLoad(FileInfo gltf, int subStrStart) { var parser = new GltfParser(); try { parser.ParsePath(gltf.FullName); } catch (Exception ex) { Debug.LogError($"ParseError: {gltf}"); Debug.LogException(ex); } try { using (var importer = new ImporterContext(parser)) { importer.Load(); } } catch (Exception ex) { Message(gltf.FullName.Substring(subStrStart), ex); } }
public void UniGLTFSimpleSceneTest() { var go = CreateSimpleScene(); // export var data = new ExportingGltfData(); string json = null; using (var exporter = new gltfExporter(data, new GltfExportSettings())) { exporter.Prepare(go); exporter.Export(new EditorTextureSerializer()); // remove empty buffer data.GLTF.buffers.Clear(); json = data.GLTF.ToJson(); } // parse var parsed = GltfData.CreateFromExportForTest(data); // import using (var context = new ImporterContext(parsed)) using (var loaded = context.Load()) { AssertAreEqual(go.transform, loaded.transform); } }
public void TextureExtractTest() { var path = GetGltfTestModelPath("BoomBox.glb"); if (path == null) { return; } // parse var data = new GlbFileParser(path.FullName).Parse(); // load using (var context = new ImporterContext(data)) { var instance = context.Load(); var textureMap = instance.RuntimeResources .Select(kv => (kv.Item1, kv.Item2 as Texture)) .Where(kv => kv.Item2 != null) .ToDictionary(kv => kv.Item1, kv => kv.Item2) ; // extractor var extractor = new TextureExtractor(data, UnityPath.FromUnityPath(""), textureMap); var m = context.TextureDescriptorGenerator.Get().GetEnumerable() .FirstOrDefault(x => x.SubAssetKey.Name == "texture_1.standard"); Assert.Catch <NotImplementedException>(() => extractor.Extract(m.SubAssetKey, m)); } }
public static ImporterContext Load(string path) { var context = new ImporterContext(); context.Load(path); context.ShowMeshes(); context.EnableUpdateWhenOffscreen(); return(context); }
public void MeshHasNoRendererTest() { var go = new GameObject("mesh_has_no_renderer"); try { { var cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.SetParent(go.transform); UnityEngine.Object.DestroyImmediate(cube.GetComponent <MeshRenderer>()); } // export var gltf = new glTF(); string json; using (var exporter = new gltfExporter(gltf)) { exporter.Prepare(go); exporter.Export(UniGLTF.MeshExportSettings.Default, AssetTextureUtil.IsTextureEditorAsset, AssetTextureUtil.GetTextureBytesWithMime); json = gltf.ToJson(); } Assert.AreEqual(0, gltf.meshes.Count); Assert.AreEqual(1, gltf.nodes.Count); Assert.AreEqual(-1, gltf.nodes[0].mesh); // import { var parser = new GltfParser(); parser.ParseJson(json, new SimpleStorage(new ArraySegment <byte>(new byte[1024 * 1024]))); using (var context = new ImporterContext(parser)) { context.Load(); Assert.AreEqual(1, context.Root.transform.GetChildren().Count()); { var child = context.Root.transform.GetChild(0); Assert.IsNull(child.GetSharedMesh()); } } } } finally { GameObject.DestroyImmediate(go); } }
IEnumerator Start() { Debug.LogFormat("get {0}", m_url); var www = new WWW(m_url); yield return(www); var bytes = www.bytes; if (!string.IsNullOrEmpty(www.error)) { Debug.LogWarningFormat("fail to download: {0}", www.error); yield break; } Debug.LogFormat("downloaded {0} bytes", bytes.Length); var task = CoroutineUtil.RunOnThread(() => Zip.ZipArchiveStorage.Parse(bytes)); yield return(task); if (task.Error != null) { throw task.Error; } var zipArchive = task.Result; Debug.LogFormat("done {0}", zipArchive); var gltf = zipArchive.Entries.FirstOrDefault(x => x.FileName.ToLower().EndsWith(".gltf")); if (gltf == null) { Debug.LogWarning("no gltf in archive"); yield break; } #if false var json = zipArchive.ExtractToString(gltf, Encoding.UTF8); #else var jsonBytes = zipArchive.Extract(gltf); var json = Encoding.UTF8.GetString(jsonBytes); #endif Debug.LogFormat("gltf json: {0}", json); var context = new ImporterContext(); context.ParseJson(json, zipArchive); context.Load(); context.ShowMeshes(); }
/// <summary> /// glb をパースして、UnityObject化、さらにAsset化する /// </summary> /// <param name="scriptedImporter"></param> /// <param name="context"></param> /// <param name="reverseAxis"></param> public static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, Axises reverseAxis) { #if VRM_DEVELOP Debug.Log("OnImportAsset to " + scriptedImporter.assetPath); #endif // // Parse(parse glb, parser gltf json) // var parser = new GltfParser(); parser.ParsePath(scriptedImporter.assetPath); // // 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, null, externalObjectMap.Concat(externalTextures))) { // settings TextureImporters foreach (var textureInfo in GltfTextureEnumerator.Enumerate(parser.GLTF)) { TextureImporterConfigurator.Configure(textureInfo, loaded.TextureFactory.ExternalMap); } loaded.InvertAxis = reverseAxis; loaded.Load(); loaded.ShowMeshes(); loaded.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); } return(true); }); } }
public void MeshHasNoRendererTest() { var go = new GameObject("mesh_has_no_renderer"); try { { var cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.SetParent(go.transform); UnityEngine.Object.DestroyImmediate(cube.GetComponent <MeshRenderer>()); } // export var gltf = new glTF(); string json; using (var exporter = new gltfExporter(gltf, new GltfExportSettings())) { exporter.Prepare(go); exporter.Export(new UniGLTF.GltfExportSettings(), new EditorTextureSerializer()); json = gltf.ToJson(); } Assert.AreEqual(0, gltf.meshes.Count); Assert.AreEqual(1, gltf.nodes.Count); Assert.AreEqual(-1, gltf.nodes[0].mesh); // import { var storage = new SimpleStorage(new ArraySegment <byte>(new byte[1024 * 1024])); var data = new JsonWithStorageParser(json, storage).Parse(); using (var context = new ImporterContext(data)) using (var loaded = context.Load()) { Assert.AreEqual(1, loaded.transform.GetChildren().Count()); { var child = loaded.transform.GetChild(0); Assert.IsNull(child.GetSharedMesh()); } } } } finally { GameObject.DestroyImmediate(go); } }
public void MeshHasNoRendererTest() { var go = new GameObject("mesh_has_no_renderer"); try { { var cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.SetParent(go.transform); UnityEngine.Object.DestroyImmediate(cube.GetComponent <MeshRenderer>()); } // export var data = new ExportingGltfData(); var gltf = data.GLTF; string json; using (var exporter = new gltfExporter(data, new GltfExportSettings())) { exporter.Prepare(go); exporter.Export(new EditorTextureSerializer()); json = gltf.ToJson(); } Assert.AreEqual(0, gltf.meshes.Count); Assert.AreEqual(1, gltf.nodes.Count); Assert.AreEqual(-1, gltf.nodes[0].mesh); // import { var parsed = GltfData.CreateFromExportForTest(data); using (var context = new ImporterContext(parsed)) using (var loaded = context.Load()) { Assert.AreEqual(1, loaded.transform.GetChildren().Count()); { var child = loaded.transform.GetChild(0); Assert.IsNull(child.GetSharedMesh()); } } } } finally { GameObject.DestroyImmediate(go); } }
/// <summary> /// glb をパースして、UnityObject化、さらにAsset化する /// </summary> /// <param name="scriptedImporter"></param> /// <param name="context"></param> /// <param name="reverseAxis"></param> protected static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, Axes reverseAxis, RenderPipelineTypes renderPipeline) { #if VRM_DEVELOP Debug.Log("OnImportAsset to " + scriptedImporter.assetPath); #endif // // Parse(parse glb, parser gltf json) // var data = new AutoGltfFileParser(scriptedImporter.assetPath).Parse(); // // Import(create unity objects) // // 2 回目以降の Asset Import において、 Importer の設定で Extract した UnityEngine.Object が入る var extractedObjects = scriptedImporter.GetExternalObjectMap() .Where(x => x.Value != null) .ToDictionary(kv => new SubAssetKey(kv.Value.GetType(), kv.Key.name), kv => kv.Value); IMaterialDescriptorGenerator materialGenerator = GetMaterialGenerator(renderPipeline); using (var loader = new ImporterContext(data, extractedObjects, materialGenerator: materialGenerator)) { // Configure TextureImporter to Extracted Textures. foreach (var textureInfo in loader.TextureDescriptorGenerator.Get().GetEnumerable()) { TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalTextures); } loader.InvertAxis = reverseAxis; var loaded = loader.Load(); loaded.ShowMeshes(); loaded.TransferOwnership((k, o) => { context.AddObjectToAsset(k.Name, o); }); var root = loaded.Root; GameObject.DestroyImmediate(loaded); context.AddObjectToAsset(root.name, root); context.SetMainObject(root); } }
public void UniGLTFSimpleSceneTest() { var go = CreateSimpleScene(); ImporterContext context = default; try { // export var gltf = new glTF(); string json = null; using (var exporter = new gltfExporter(gltf)) { exporter.Prepare(go); exporter.Export(MeshExportSettings.Default); // remove empty buffer gltf.buffers.Clear(); json = gltf.ToJson(); } // parse var parser = new GltfParser(); parser.ParseJson(json, new SimpleStorage(new ArraySegment <byte>())); // import context = new ImporterContext(parser); context.Load(); AssertAreEqual(go.transform, context.Root.transform); } finally { //Debug.LogFormat("Destroy, {0}", go.name); GameObject.DestroyImmediate(go); if (context != null) { var editor = new EditorImporterContext(context); editor.EditorDestroyRootAndAssets(); } } }
GameObject Load(string path) { var bytes = File.ReadAllBytes(path); Debug.LogFormat("[OnClick] {0}", path); var context = new ImporterContext(); var ext = Path.GetExtension(path).ToLower(); switch (ext) { case ".gltf": context.ParseJson(Encoding.UTF8.GetString(bytes), new FileSystemStorage(Path.GetDirectoryName(path))); break; case ".zip": { var zipArchive = Zip.ZipArchiveStorage.Parse(bytes); var gltf = zipArchive.Entries.FirstOrDefault(x => x.FileName.ToLower().EndsWith(".gltf")); if (gltf == null) { throw new Exception("no gltf in archive"); } var jsonBytes = zipArchive.Extract(gltf); var json = Encoding.UTF8.GetString(jsonBytes); context.ParseJson(json, zipArchive); } break; case ".glb": context.ParseGlb(bytes); break; default: throw new NotImplementedException(); } context.Load(); context.Root.name = Path.GetFileNameWithoutExtension(path); context.ShowMeshes(); return(context.Root); }
public static void ImportMenu() { var path = EditorUtility.OpenFilePanel("open gltf", "", "gltf,glb"); if (string.IsNullOrEmpty(path)) { return; } if (Application.isPlaying) { // // load into scene // var parser = new GltfParser(); parser.ParsePath(path); var context = new ImporterContext(parser); context.Load(); context.ShowMeshes(); Selection.activeGameObject = context.Root; } else { // // save as asset // if (path.StartsWithUnityAssetPath()) { Debug.LogWarningFormat("disallow import from folder under the Assets"); return; } var assetPath = EditorUtility.SaveFilePanel("save prefab", "Assets", Path.GetFileNameWithoutExtension(path), "prefab"); if (string.IsNullOrEmpty(path)) { return; } // import as asset gltfAssetPostprocessor.ImportAsset(path, Path.GetExtension(path).ToLower(), UnityPath.FromFullpath(assetPath)); } }
static void RuntimeLoadExport(FileInfo gltf, int subStrStart) { var parser = new GltfParser(); try { parser.ParsePath(gltf.FullName); } catch (Exception ex) { Debug.LogError($"ParseError: {gltf}"); Debug.LogException(ex); } using (var loader = new ImporterContext(parser)) { try { loader.Load(); } catch (Exception ex) { Message(gltf.FullName.Substring(subStrStart), ex); } if (Skip.Contains(gltf.Directory.Parent.Name)) { // Export issue: // skip return; } if (loader.Root == null) { Debug.LogWarning($"root is null: ${gltf}"); return; } Export(loader.Root); } }
static void RuntimeLoadExport(FileInfo gltf, int subStrStart) { GltfData data = null; try { data = new AutoGltfFileParser(gltf.FullName).Parse(); } catch (Exception ex) { Debug.LogError($"ParseError: {gltf}"); Debug.LogException(ex); } using (data) using (var loader = new ImporterContext(data)) { try { var loaded = loader.Load(); if (loaded == null) { Debug.LogWarning($"root is null: ${gltf}"); return; } if (Skip.Contains(gltf.Directory.Parent.Name)) { // Export issue: // skip return; } Export(loaded.gameObject); } catch (Exception ex) { Message(gltf.FullName.Substring(subStrStart), ex); } } }
public void ImportExportTest() { var path = Path.GetFullPath(Application.dataPath + "/../glTF-Sample-Models/2.0/Box/glTF/Box.gltf"); var context = new ImporterContext(); var bytes = File.ReadAllBytes(path); var importJson = Encoding.UTF8.GetString(bytes); context.ParseJson(importJson, new FileSystemStorage(Path.GetDirectoryName(path))); context.Load(); var gltf = gltfExporter.Export(context.Root); var exportJson = gltf.ToJson(); var l = UniJSON.JsonParser.Parse(importJson); var r = UniJSON.JsonParser.Parse(exportJson); foreach (var diff in l.Diff(r)) { Debug.Log(diff); } //Assert.AreEqual(); }
public void SameMeshButDifferentMaterialExport() { var go = new GameObject("same_mesh"); try { var shader = Shader.Find("Unlit/Color"); var cubeA = GameObject.CreatePrimitive(PrimitiveType.Cube); { cubeA.transform.SetParent(go.transform); var material = new Material(shader); material.name = "red"; material.color = Color.red; cubeA.GetComponent <Renderer>().sharedMaterial = material; } { var cubeB = GameObject.Instantiate(cubeA); cubeB.transform.SetParent(go.transform); var material = new Material(shader); material.color = Color.blue; material.name = "blue"; cubeB.GetComponent <Renderer>().sharedMaterial = material; Assert.AreEqual(cubeB.GetComponent <MeshFilter>().sharedMesh, cubeA.GetComponent <MeshFilter>().sharedMesh); } // export var data = new ExportingGltfData(); var gltf = data.GLTF; var json = default(string); using (var exporter = new gltfExporter(data, new GltfExportSettings())) { exporter.Prepare(go); exporter.Export(new EditorTextureSerializer()); json = gltf.ToJson(); } Assert.AreEqual(2, gltf.meshes.Count); var red = gltf.materials[gltf.meshes[0].primitives[0].material]; Assert.AreEqual(new float[] { 1, 0, 0, 1 }, red.pbrMetallicRoughness.baseColorFactor); var blue = gltf.materials[gltf.meshes[1].primitives[0].material]; Assert.AreEqual(new float[] { 0, 0, 1, 1 }, blue.pbrMetallicRoughness.baseColorFactor); Assert.AreEqual(2, gltf.nodes.Count); Assert.AreNotEqual(gltf.nodes[0].mesh, gltf.nodes[1].mesh); // import { var parsed = GltfData.CreateFromExportForTest(data); using (var context = new ImporterContext(parsed)) using (var loaded = context.Load()) { var importedRed = loaded.transform.GetChild(0); var importedRedMaterial = importedRed.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("red", importedRedMaterial.name); Assert.AreEqual(Color.red, importedRedMaterial.color); var importedBlue = loaded.transform.GetChild(1); var importedBlueMaterial = importedBlue.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("blue", importedBlueMaterial.name); Assert.AreEqual(Color.blue, importedBlueMaterial.color); } } // import new version { var parsed = GltfData.CreateFromExportForTest(data); using (var context = new ImporterContext(parsed)) using (var loaded = context.Load()) { var importedRed = loaded.transform.GetChild(0); var importedRedMaterial = importedRed.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("red", importedRedMaterial.name); Assert.AreEqual(Color.red, importedRedMaterial.color); var importedBlue = loaded.transform.GetChild(1); var importedBlueMaterial = importedBlue.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("blue", importedBlueMaterial.name); Assert.AreEqual(Color.blue, importedBlueMaterial.color); } } } finally { GameObject.DestroyImmediate(go); } }
void LoadModel(string path) { if (!File.Exists(path)) { return; } Debug.LogFormat("{0}", path); var ext = Path.GetExtension(path).ToLower(); switch (ext) { case ".vrm": { var parser = new UniGLTF.GltfParser(); parser.ParsePath(path); using (var loader = new RuntimeUnityBuilder(parser)) { loader.Load(); loader.ShowMeshes(); loader.EnableUpdateWhenOffscreen(); var destroyer = loader.DisposeOnGameObjectDestroyed(); SetModel(destroyer.gameObject); } break; } case ".glb": { var file = File.ReadAllBytes(path); var parser = new GltfParser(); parser.ParseGlb(file); using (var loader = new UniGLTF.ImporterContext(parser)) { loader.Load(); loader.ShowMeshes(); loader.EnableUpdateWhenOffscreen(); loader.ShowMeshes(); var destroyer = loader.DisposeOnGameObjectDestroyed(); SetModel(destroyer.gameObject); } break; } case ".gltf": case ".zip": { var parser = new GltfParser(); parser.ParsePath(path); using (var loader = new UniGLTF.ImporterContext(parser)) { loader.Load(); loader.ShowMeshes(); loader.EnableUpdateWhenOffscreen(); loader.ShowMeshes(); var destroyer = loader.DisposeOnGameObjectDestroyed(); SetModel(destroyer.gameObject); } break; } default: Debug.LogWarningFormat("unknown file type: {0}", path); break; } }
public static void Load(ImporterContext context) { context.Load(); context.ShowMeshes(); context.EnableUpdateWhenOffscreen(); }
void LoadModel(string path) { if (!File.Exists(path)) { return; } Debug.LogFormat("{0}", path); var ext = Path.GetExtension(path).ToLower(); switch (ext) { case ".vrm": { if (!Vrm10Parser.TryParseOrMigrate(path, doMigrate: true, out Vrm10Parser.Result result)) { Debug.LogError(result.Message); return; } using (var loader = new Vrm10Importer(result.Data, result.Vrm)) { var loaded = loader.Load(); loaded.ShowMeshes(); loaded.EnableUpdateWhenOffscreen(); SetModel(loaded.gameObject); } break; } case ".glb": { var data = new GlbFileParser(path).Parse(); using (var loader = new UniGLTF.ImporterContext(data)) { var loaded = loader.Load(); loaded.ShowMeshes(); loaded.EnableUpdateWhenOffscreen(); SetModel(loaded.gameObject); } break; } case ".gltf": { var data = new GltfFileWithResourceFilesParser(path).Parse(); using (var loader = new UniGLTF.ImporterContext(data)) { var loaded = loader.Load(); loaded.ShowMeshes(); loaded.EnableUpdateWhenOffscreen(); SetModel(loaded.gameObject); } break; } case ".zip": { var data = new ZipArchivedGltfFileParser(path).Parse(); using (var loader = new UniGLTF.ImporterContext(data)) { var loaded = loader.Load(); loaded.ShowMeshes(); loaded.EnableUpdateWhenOffscreen(); SetModel(loaded.gameObject); } break; } default: Debug.LogWarningFormat("unknown file type: {0}", path); break; } }
async void LoadModelAsync(string path) { if (!File.Exists(path)) { return; } Debug.LogFormat("{0}", path); var ext = Path.GetExtension(path).ToLower(); switch (ext) { case ".vrm": { var data = new GlbFileParser(path).Parse(); using (var context = new VRMImporterContext(data)) { await m_texts.UpdateMetaAsync(context); var loaded = await context.LoadAsync(); loaded.EnableUpdateWhenOffscreen(); loaded.ShowMeshes(); SetModel(loaded.gameObject); } break; } case ".glb": { var data = new GlbFileParser(path).Parse(); var context = new UniGLTF.ImporterContext(data); var loaded = context.Load(); loaded.EnableUpdateWhenOffscreen(); loaded.ShowMeshes(); SetModel(loaded.gameObject); break; } case ".gltf": { var data = new GltfFileWithResourceFilesParser(path).Parse(); var context = new UniGLTF.ImporterContext(data); var loaded = context.Load(); loaded.EnableUpdateWhenOffscreen(); loaded.ShowMeshes(); SetModel(loaded.gameObject); break; } case ".zip": { var data = new ZipArchivedGltfFileParser(path).Parse(); var context = new UniGLTF.ImporterContext(data); var loaded = context.Load(); loaded.EnableUpdateWhenOffscreen(); loaded.ShowMeshes(); SetModel(loaded.gameObject); break; } default: Debug.LogWarningFormat("unknown file type: {0}", path); break; } }
public void ExportingNullMeshTest() { var validator = ScriptableObject.CreateInstance <MeshExportValidator>(); var root = new GameObject("root"); try { { var child = GameObject.CreatePrimitive(PrimitiveType.Cube); child.transform.SetParent(root.transform); // remove MeshFilter Component.DestroyImmediate(child.GetComponent <MeshFilter>()); } { var child = GameObject.CreatePrimitive(PrimitiveType.Cube); child.transform.SetParent(root.transform); // set null child.GetComponent <MeshFilter>().sharedMesh = null; } // validate validator.SetRoot(root, new GltfExportSettings(), new DefualtBlendShapeExportFilter()); var vs = validator.Validate(root); Assert.True(vs.All(x => x.CanExport)); // export var data = new ExportingGltfData(); var gltf = data.GLTF; string json; using (var exporter = new gltfExporter(data, new GltfExportSettings())) { exporter.Prepare(root); exporter.Export(new EditorTextureSerializer()); json = gltf.ToJson(); } Assert.AreEqual(0, gltf.meshes.Count); Assert.AreEqual(2, gltf.nodes.Count); Assert.AreEqual(-1, gltf.nodes[0].mesh); Assert.AreEqual(-1, gltf.nodes[1].mesh); // import { var parsed = GltfData.CreateFromExportForTest(data); using (var context = new ImporterContext(parsed)) using (var loaded = context.Load()) { Assert.AreEqual(2, loaded.transform.GetChildren().Count()); { var child = loaded.transform.GetChild(0); Assert.IsNull(child.GetSharedMesh()); } { var child = loaded.transform.GetChild(1); Assert.IsNull(child.GetSharedMesh()); } } } } finally { GameObject.DestroyImmediate(root); ScriptableObject.DestroyImmediate(validator); } }
async void LoadModelAsync(string path) { if (!File.Exists(path)) { return; } Debug.LogFormat("{0}", path); var ext = Path.GetExtension(path).ToLower(); switch (ext) { case ".vrm": { var file = File.ReadAllBytes(path); var parser = new GltfParser(); parser.ParseGlb(file); using (var context = new VRMImporterContext(parser)) { await m_texts.UpdateMetaAsync(context); await context.LoadAsync(); context.EnableUpdateWhenOffscreen(); context.ShowMeshes(); context.DisposeOnGameObjectDestroyed(); SetModel(context.Root); } break; } case ".glb": { var file = File.ReadAllBytes(path); var parser = new GltfParser(); parser.ParseGlb(file); var context = new UniGLTF.ImporterContext(parser); context.Load(); context.EnableUpdateWhenOffscreen(); context.ShowMeshes(); context.DisposeOnGameObjectDestroyed(); SetModel(context.Root); break; } case ".gltf": case ".zip": { var parser = new GltfParser(); parser.ParsePath(path); var context = new UniGLTF.ImporterContext(parser); context.Load(); context.EnableUpdateWhenOffscreen(); context.ShowMeshes(); context.DisposeOnGameObjectDestroyed(); SetModel(context.Root); break; } default: Debug.LogWarningFormat("unknown file type: {0}", path); break; } }
public void SameMeshButDifferentMaterialExport() { var go = new GameObject("same_mesh"); try { var shader = Shader.Find("Unlit/Color"); var cubeA = GameObject.CreatePrimitive(PrimitiveType.Cube); { cubeA.transform.SetParent(go.transform); var material = new Material(shader); material.name = "red"; material.color = Color.red; cubeA.GetComponent <Renderer>().sharedMaterial = material; } { var cubeB = GameObject.Instantiate(cubeA); cubeB.transform.SetParent(go.transform); var material = new Material(shader); material.color = Color.blue; material.name = "blue"; cubeB.GetComponent <Renderer>().sharedMaterial = material; Assert.AreEqual(cubeB.GetComponent <MeshFilter>().sharedMesh, cubeA.GetComponent <MeshFilter>().sharedMesh); } // export var gltf = new glTF(); var json = default(string); using (var exporter = new gltfExporter(gltf)) { exporter.Prepare(go); exporter.Export(); json = gltf.ToJson(); } Assert.AreEqual(2, gltf.meshes.Count); var red = gltf.materials[gltf.meshes[0].primitives[0].material]; Assert.AreEqual(new float[] { 1, 0, 0, 1 }, red.pbrMetallicRoughness.baseColorFactor); var blue = gltf.materials[gltf.meshes[1].primitives[0].material]; Assert.AreEqual(new float[] { 0, 0, 1, 1 }, blue.pbrMetallicRoughness.baseColorFactor); Assert.AreEqual(2, gltf.nodes.Count); Assert.AreNotEqual(gltf.nodes[0].mesh, gltf.nodes[1].mesh); // import { var context = new ImporterContext(); context.ParseJson(json, new SimpleStorage(new ArraySegment <byte>(new byte[1024 * 1024]))); //Debug.LogFormat("{0}", context.Json); context.Load(); var importedRed = context.Root.transform.GetChild(0); var importedRedMaterial = importedRed.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("red", importedRedMaterial.name); Assert.AreEqual(Color.red, importedRedMaterial.color); var importedBlue = context.Root.transform.GetChild(1); var importedBlueMaterial = importedBlue.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("blue", importedBlueMaterial.name); Assert.AreEqual(Color.blue, importedBlueMaterial.color); } // import new version { var context = new ImporterContext { UseUniJSONParser = true }; context.ParseJson(json, new SimpleStorage(new ArraySegment <byte>(new byte[1024 * 1024]))); //Debug.LogFormat("{0}", context.Json); context.Load(); var importedRed = context.Root.transform.GetChild(0); var importedRedMaterial = importedRed.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("red", importedRedMaterial.name); Assert.AreEqual(Color.red, importedRedMaterial.color); var importedBlue = context.Root.transform.GetChild(1); var importedBlueMaterial = importedBlue.GetComponent <Renderer>().sharedMaterial; Assert.AreEqual("blue", importedBlueMaterial.name); Assert.AreEqual(Color.blue, importedBlueMaterial.color); } } finally { GameObject.DestroyImmediate(go); } }
public override void OnImportAsset(AssetImportContext ctx) { Debug.Log("OnImportAsset to " + ctx.assetPath); try { // Parse var parser = new GltfParser(); parser.ParsePath(ctx.assetPath); // Build Unity Model var externalObjectMap = GetExternalObjectMap() .Select(kv => (kv.Key.name, kv.Value)) ; var context = new ImporterContext(parser, externalObjectMap); context.InvertAxis = m_reverseAxis; context.Load(); context.ShowMeshes(); // Texture foreach (var info in context.TextureFactory.Textures) { if (!info.IsUsed) { continue; } if (!info.IsExternal) { var texture = info.Texture; ctx.AddObjectToAsset(texture.name, texture); } } // Material foreach (var info in context.MaterialFactory.Materials) { if (!info.UseExternal) { var material = info.Asset; ctx.AddObjectToAsset(material.name, material); } } // Mesh foreach (var mesh in context.Meshes.Select(x => x.Mesh)) { ctx.AddObjectToAsset(mesh.name, mesh); } // Animation foreach (var clip in context.AnimationClips) { ctx.AddObjectToAsset(clip.name, clip); } // Root ctx.AddObjectToAsset(context.Root.name, context.Root); ctx.SetMainObject(context.Root); } catch (System.Exception ex) { Debug.LogError(ex); } }