private static Schedulable <GameObject> LoadVrmAsyncInternal(VRMImporterContext ctx, bool show) { var schedulable = Schedulable.Create(); return(schedulable .AddTask(Scheduler.ThreadPool, () => { return glTF_VRM_Material.Parse(ctx.Json); }) .ContinueWith(Scheduler.MainThread, x => { // material function ctx.CreateMaterial = VRMImporter.GetMaterialFunc(x); }) .OnExecute(Scheduler.ThreadPool, parent => { // textures for (int i = 0; i < ctx.GLTF.textures.Count; ++i) { var index = i; parent.AddTask(Scheduler.MainThread, () => { var texture = new TextureItem(ctx.GLTF, index); texture.Process(ctx.GLTF, ctx.Storage); return texture; }) .ContinueWith(Scheduler.ThreadPool, x => ctx.Textures.Add(x)); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadMaterials(ctx)) .OnExecute(Scheduler.ThreadPool, parent => { // meshes for (int i = 0; i < ctx.GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => gltfImporter.ReadMesh(ctx, index)) .ContinueWith(Scheduler.MainThread, x => gltfImporter.BuildMesh(ctx, x)) .ContinueWith(Scheduler.ThreadPool, x => ctx.Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadNodes(ctx)) .ContinueWithCoroutine(Scheduler.MainThread, () => BuildHierarchy(ctx)) .ContinueWith(Scheduler.CurrentThread, _ => VRMImporter.OnLoadModel(ctx)) .ContinueWith(Scheduler.CurrentThread, _ => { ctx.Root.name = "VRM"; if (show) { ctx.ShowMeshes(); } return ctx.Root; })); }
protected virtual Schedulable <Unit> LoadAsync() { return (Schedulable.Create() .AddTask(Scheduler.ThreadPool, () => { m_materialFactory.Prepare(GLTF); }) .ContinueWithCoroutine(Scheduler.ThreadPool, () => m_materialFactory.TexturesProcessOnAnyThread(GLTF, Storage)) .ContinueWithCoroutine(Scheduler.MainThread, () => m_materialFactory.TexturesProcessOnMainThread(GLTF)) .ContinueWithCoroutine(Scheduler.MainThread, () => m_materialFactory.LoadMaterials(GLTF)) .OnExecute(Scheduler.ThreadPool, parent => { // UniGLTF does not support draco // https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md#conformance if (GLTF.extensionsRequired.Contains("KHR_draco_mesh_compression")) { throw new UniGLTFNotSupportedException("draco is not supported"); } // meshes var meshImporter = new MeshImporter(); for (int i = 0; i < GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => { using (MeasureTime("ReadMesh")) { return meshImporter.ReadMesh(this, index); } }) .ContinueWithCoroutine <MeshWithMaterials>(Scheduler.MainThread, x => BuildMesh(x, index)) .ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, LoadNodes) .ContinueWithCoroutine(Scheduler.MainThread, BuildHierarchy) .ContinueWith(Scheduler.MainThread, _ => { using (MeasureTime("AnimationImporter")) { AnimationImporter.Import(this); } }) .ContinueWithCoroutine(Scheduler.MainThread, OnLoadModel) .ContinueWith(Scheduler.CurrentThread, _ => { if (m_showSpeedLog) { Debug.Log(GetSpeedLog()); } return Unit.Default; })); }
private static Schedulable <GameObject> LoadVrmAsyncInternal(VRMImporterContext ctx) { var schedulable = Schedulable.Create(); return(schedulable .AddTask(Scheduler.ThreadPool, () => { ctx.GLTF.baseDir = Path.GetDirectoryName(ctx.Path); return Unit.Default; }) .ContinueWith(Scheduler.ThreadPool, _ => { return glTF_VRM_Material.Parse(ctx.Json); }) .ContinueWith(Scheduler.MainThread, x => { // material function ctx.CreateMaterial = VRMImporter.GetMaterialFunc(x); }) .OnExecute(Scheduler.ThreadPool, parent => { // textures for (int i = 0; i < ctx.GLTF.textures.Count; ++i) { var index = i; parent.AddTask(Scheduler.MainThread, () => { var texture = new TextureItem(ctx.GLTF, index); texture.Process(); return texture; }) .ContinueWith(Scheduler.ThreadPool, x => ctx.Textures.Add(x)); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadMaterials(ctx)) .OnExecute(Scheduler.ThreadPool, parent => { // meshes for (int i = 0; i < ctx.GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => gltfImporter.ReadMesh(ctx, index)) .ContinueWith(Scheduler.MainThread, x => gltfImporter.BuildMesh(ctx, x)) .ContinueWith(Scheduler.ThreadPool, x => ctx.Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadNodes(ctx)) .ContinueWithCoroutine(Scheduler.MainThread, () => BuildHierarchy(ctx)) .ContinueWith(Scheduler.MainThread, _ => VRMImporter.OnLoadModel(ctx)) .ContinueWith(Scheduler.MainThread, _ => { /* * Debug.LogFormat("task end: {0}/{1}/{2}/{3}", * ctx.Textures.Count, * ctx.Materials.Count, * ctx.Meshes.Count, * ctx.Nodes.Count * ); */ ctx.Root.name = Path.GetFileNameWithoutExtension(ctx.Path); // 非表示のメッシュを表示する ctx.ShowMeshes(); return ctx.Root; })); }
protected virtual Schedulable <Unit> LoadAsync() { return (Schedulable.Create() .AddTask(Scheduler.ThreadPool, () => { if (m_textures.Count == 0) { // // runtime // CreateTextureItems(); } else { // // already CreateTextures(by assetPostProcessor or editor menu) // } }) .ContinueWithCoroutine(Scheduler.ThreadPool, TexturesProcessOnAnyThread) .ContinueWithCoroutine(Scheduler.MainThread, TexturesProcessOnMainThread) .ContinueWithCoroutine(Scheduler.MainThread, LoadMaterials) .OnExecute(Scheduler.ThreadPool, parent => { // UniGLTF does not support draco // https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md#conformance if (GLTF.extensionsRequired.Contains("KHR_draco_mesh_compression")) { throw new UniGLTFNotSupportedException("draco is not supported"); } // meshes var meshImporter = new MeshImporter(); for (int i = 0; i < GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => { using (MeasureTime("ReadMesh")) { return meshImporter.ReadMesh(this, index); } }) .ContinueWith(Scheduler.MainThread, x => { using (MeasureTime("BuildMesh")) { var meshWithMaterials = MeshImporter.BuildMesh(this, x); var mesh = meshWithMaterials.Mesh; // mesh name if (string.IsNullOrEmpty(mesh.name)) { mesh.name = string.Format("UniGLTF import#{0}", i); } var originalName = mesh.name; for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j) { mesh.name = string.Format("{0}({1})", originalName, j); } return meshWithMaterials; } }) .ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, LoadNodes) .ContinueWithCoroutine(Scheduler.MainThread, BuildHierarchy) .ContinueWith(Scheduler.MainThread, _ => { using (MeasureTime("AnimationImporter")) { AnimationImporter.ImportAnimation(this); } }) .ContinueWith(Scheduler.CurrentThread, _ => { OnLoadModel(); if (m_showSpeedLog) { Debug.Log(GetSpeedLog()); } return Unit.Default; })); }
public static void LoadVrmAsync(VRMImporterContext ctx, ArraySegment <Byte> chunkData, Action <GameObject> onLoaded) { var schedulable = Schedulable.Create(); schedulable .AddTask(MainThreadDispatcher.Instance.ThreadScheduler, () => { ctx.GLTF.baseDir = Path.GetDirectoryName(ctx.Path); foreach (var buffer in ctx.GLTF.buffers) { buffer.OpenStorage(ctx.GLTF.baseDir, chunkData); } return(Unit.Default); }) .ContinueWith(MainThreadDispatcher.Instance.ThreadScheduler, _ => { return(glTF_VRM_Material.Parse(ctx.Json)); }) .ContinueWith(MainThreadDispatcher.Instance.UnityScheduler, x => { // material function ctx.CreateMaterial = VRMImporter.GetMaterialFunc(x); }) .OnExecute(MainThreadDispatcher.Instance.UnityScheduler, parent => { // textures for (int i = 0; i < ctx.GLTF.textures.Count; ++i) { var index = i; parent.AddTask(MainThreadDispatcher.Instance.UnityScheduler, () => gltfImporter.ImportTexture(ctx.GLTF, index)) .ContinueWith(MainThreadDispatcher.Instance.ThreadScheduler, x => ctx.Textures.Add(x)); } }) .ContinueWithCoroutine(MainThreadDispatcher.Instance.UnityScheduler, () => LoadMaterials(ctx)) .OnExecute(MainThreadDispatcher.Instance.UnityScheduler, parent => { // meshes for (int i = 0; i < ctx.GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(MainThreadDispatcher.Instance.ThreadScheduler, () => gltfImporter.ReadMesh(ctx, index)) .ContinueWith(MainThreadDispatcher.Instance.UnityScheduler, x => gltfImporter.BuildMesh(ctx, x)) .ContinueWith(MainThreadDispatcher.Instance.ThreadScheduler, x => ctx.Meshes.Add(x)) ; } }) .ContinueWithCoroutine(MainThreadDispatcher.Instance.UnityScheduler, () => LoadNodes(ctx)) .ContinueWithCoroutine(MainThreadDispatcher.Instance.UnityScheduler, () => BuildHierarchy(ctx)) .ContinueWith(MainThreadDispatcher.Instance.UnityScheduler, _ => VRMImporter.OnLoadModel(ctx)) .Subscribe(MainThreadDispatcher.Instance.UnityScheduler, _ => { /* * Debug.LogFormat("task end: {0}/{1}/{2}/{3}", * ctx.Textures.Count, * ctx.Materials.Count, * ctx.Meshes.Count, * ctx.Nodes.Count * ); */ ctx.Root.name = Path.GetFileNameWithoutExtension(ctx.Path); // 非表示のメッシュを表示する ctx.ShowMeshes(); onLoaded(ctx.Root); }, ex => { Debug.LogError(ex); }) ; }
protected virtual Schedulable <Unit> LoadAsync() { return (Schedulable.Create() .AddTask(Scheduler.ThreadPool, () => { if (m_textures.Count == 0) { // // runtime // CreateTextureItems(); } else { // // already CreateTextures(by assetPostProcessor or editor menu) // } }) .ContinueWithCoroutine(Scheduler.ThreadPool, () => { using (MeasureTime("TexturesProcessOnAnyThread")) { return TexturesProcessOnAnyThread(); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("TexturesProcessOnMainThread")) { return TexturesProcessOnMainThread(); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("LoadMaterials")) { return LoadMaterials(); } }) .OnExecute(Scheduler.ThreadPool, parent => { if (GLTF.meshes .SelectMany(x => x.primitives) .Any(x => x.extensions.KHR_draco_mesh_compression != null)) { throw new UniGLTFNotSupportedException("draco is not supported"); } // meshes var meshImporter = new MeshImporter(); for (int i = 0; i < GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => { using (MeasureTime("ReadMesh")) { return meshImporter.ReadMesh(this, index); } }) .ContinueWith(Scheduler.MainThread, x => { using (MeasureTime("BuildMesh")) { var meshWithMaterials = MeshImporter.BuildMesh(this, x); var mesh = meshWithMaterials.Mesh; // mesh name if (string.IsNullOrEmpty(mesh.name)) { mesh.name = string.Format("UniGLTF import#{0}", i); } var originalName = mesh.name; for (int j = 1; Meshes.Any(y => y.Mesh.name == mesh.name); ++j) { mesh.name = string.Format("{0}({1})", originalName, j); } return meshWithMaterials; } }) .ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("LoadNodes")) { return LoadNodes(); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("BuildHierarchy")) { return BuildHierarchy(); } }) .ContinueWith(Scheduler.MainThread, _ => { AnimationImporter.ImportAnimation(this); }) .ContinueWith(Scheduler.CurrentThread, _ => { OnLoadModel(); Debug.Log(GetSpeedLog()); return Unit.Default; })); }
private static Schedulable <GameObject> LoadVrmAsyncInternal(VRMImporterContext ctx, bool show) { return(Schedulable.Create() .AddTask(Scheduler.ThreadPool, () => { using (ctx.MeasureTime("glTF_VRM_Material.Parse")) { return glTF_VRM_Material.Parse(ctx.Json); } }) .ContinueWith(Scheduler.MainThread, gltfMaterials => { using (ctx.MeasureTime("new VRMMaterialImporter")) { ctx.MaterialImporter = new VRMMaterialImporter(ctx, gltfMaterials); } }) .OnExecute(Scheduler.ThreadPool, parent => { // textures for (int i = 0; i < ctx.GLTF.textures.Count; ++i) { var index = i; parent.AddTask(Scheduler.MainThread, () => { using (ctx.MeasureTime("texture.Process")) { var texture = new TextureItem(ctx.GLTF, index); texture.Process(ctx.GLTF, ctx.Storage); return texture; } }) .ContinueWith(Scheduler.ThreadPool, x => ctx.AddTexture(x)); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadMaterials(ctx)) .OnExecute(Scheduler.ThreadPool, parent => { // meshes for (int i = 0; i < ctx.GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => { using (ctx.MeasureTime("ReadMesh")) { return gltfImporter.ReadMesh(ctx, index); } }) .ContinueWith(Scheduler.MainThread, x => { using (ctx.MeasureTime("BuildMesh")) { return gltfImporter.BuildMesh(ctx, x); } }) .ContinueWith(Scheduler.ThreadPool, x => ctx.Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (ctx.MeasureTime("LoadNodes")) { return LoadNodes(ctx); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (ctx.MeasureTime("BuildHierarchy")) { return BuildHierarchy(ctx); } }) .ContinueWith(Scheduler.CurrentThread, _ => { //using (ctx.MeasureTime("OnLoadModel")) { return VRMImporter.OnLoadModel(ctx); } }) .ContinueWith(Scheduler.CurrentThread, _ => { ctx.Root.name = "VRM"; if (show) { ctx.ShowMeshes(); } Debug.Log(ctx.GetSpeedLog()); return ctx.Root; })); }
protected override Schedulable <Unit> LoadAsync() { return(Schedulable.Create() .AddTask(Scheduler.ThreadPool, () => { using (MeasureTime("glTF_VRM_Material.Parse")) { return glTF_VRM_Material.Parse(Json); } }) .ContinueWith(Scheduler.MainThread, gltfMaterials => { using (MeasureTime("new VRMMaterialImporter")) { SetMaterialImporter(new VRMMaterialImporter(this, gltfMaterials)); } }) .OnExecute(Scheduler.ThreadPool, parent => { // textures for (int i = 0; i < GLTF.textures.Count; ++i) { var index = i; parent.AddTask(Scheduler.MainThread, () => { using (MeasureTime("texture.Process")) { var texture = new TextureItem(index); texture.Process(GLTF, Storage); return texture; } }) .ContinueWith(Scheduler.ThreadPool, x => AddTexture(x)); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => LoadMaterials()) .OnExecute(Scheduler.ThreadPool, parent => { // meshes var meshImporter = new MeshImporter(); for (int i = 0; i < GLTF.meshes.Count; ++i) { var index = i; parent.AddTask(Scheduler.ThreadPool, () => { using (MeasureTime("ReadMesh")) { return meshImporter.ReadMesh(this, index); } }) .ContinueWith(Scheduler.MainThread, x => { using (MeasureTime("BuildMesh")) { return MeshImporter.BuildMesh(this, x); } }) .ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x)) ; } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("LoadNodes")) { return LoadNodes(); } }) .ContinueWithCoroutine(Scheduler.MainThread, () => { using (MeasureTime("BuildHierarchy")) { return BuildHierarchy(); } }) .ContinueWith(Scheduler.CurrentThread, _ => { //using (MeasureTime("OnLoadModel")) { OnLoadModel(); return Unit.Default; } }) .ContinueWith(Scheduler.CurrentThread, _ => { Root.name = "VRM"; Debug.Log(GetSpeedLog()); return Unit.Default; })); }