public static async Task Load(GameObject gameObjectLoader, string url, Action callback, Action <GameObject> onInitializeGltfObject)
    {
        ImporterFactory Factory       = null;
        bool            UseStream     = true;
        string          GLTFUri       = url;
        bool            Multithreaded = true;
        int             MaximumLod    = 300;
        int             Timeout       = 8;

        var importOptions = new ImportOptions
        {
            AsyncCoroutineHelper = gameObjectLoader.GetComponent <AsyncCoroutineHelper>() ?? gameObjectLoader.AddComponent <AsyncCoroutineHelper>()
        };

        GLTFSceneImporter sceneImporter = null;
        var cancelToken = new CancellationTokenSource();

        try
        {
            Factory = Factory ?? ScriptableObject.CreateInstance <DefaultImporterFactory>();
            if (UseStream)
            {
                var    fullPath      = GLTFUri;
                string directoryPath = URIHelper.GetDirectoryName(fullPath);
                importOptions.DataLoader = new FileLoader(directoryPath);
                sceneImporter            = Factory.CreateSceneImporter(Path.GetFileName(GLTFUri), importOptions);
            }
            else
            {
                string directoryPath = URIHelper.GetDirectoryName(GLTFUri);
                importOptions.DataLoader = new WebRequestLoader(directoryPath);
                sceneImporter            = Factory.CreateSceneImporter(URIHelper.GetFileFromUri(new Uri(GLTFUri)), importOptions);
            }
            sceneImporter.SceneParent            = gameObjectLoader.transform;
            sceneImporter.MaximumLod             = MaximumLod;
            sceneImporter.Timeout                = Timeout;
            sceneImporter.IsMultithreaded        = Multithreaded;
            sceneImporter.OnInitializeGltfObject = onInitializeGltfObject;
            mTasks.Add(cancelToken);
            await sceneImporter.LoadSceneAsync(-1, true, null, cancelToken.Token);
        }
        finally
        {
            if (importOptions.DataLoader != null)
            {
                if (sceneImporter != null)
                {
                    mCreatedScenes.Add(sceneImporter.CreatedObject);
                    if (cancelToken.IsCancellationRequested)
                    {
                        sceneImporter.CreatedObject.DestroySelf();
                    }
                    sceneImporter.Dispose();
                    sceneImporter = null;
                }
                importOptions.DataLoader = null;
            }
            callback.InvokeGracefully();
        }
    }
Beispiel #2
0
    IEnumerator Start()
    {
        GLTFSceneImporter sceneImporter = null;
        ILoader           loader        = null;

        if (UseStream)
        {
            // Path.Combine treats paths that start with the separator character
            // as absolute paths, ignoring the first path passed in. This removes
            // that character to properly handle a filename written with it.
            GLTFUri = GLTFUri.TrimStart(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
            string fullPath      = Path.Combine(Application.streamingAssetsPath, GLTFUri);
            string directoryPath = URIHelper.GetDirectoryName(fullPath);
            loader        = new FileLoader(directoryPath);
            sceneImporter = new GLTFSceneImporter(
                Path.GetFileName(GLTFUri),
                loader
                );
        }
        else
        {
            string directoryPath = URIHelper.GetDirectoryName(GLTFUri);
            loader        = new WebRequestLoader(directoryPath);
            sceneImporter = new GLTFSceneImporter(
                URIHelper.GetFileFromUri(new Uri(GLTFUri)),
                loader
                );
        }

        sceneImporter.SceneParent = gameObject.transform;
        sceneImporter.Collider    = Colliders;
        sceneImporter.MaximumLod  = MaximumLod;
        yield return(sceneImporter.LoadScene(-1, Multithreaded, HandleAction));
    }
        void Start()
        {
            Debug.Log("Hit spacebar to change the scene.");
            _asyncCoroutineHelper = gameObject.AddComponent <AsyncCoroutineHelper>();
            Uri uri           = new Uri(Url);
            var directoryPath = URIHelper.AbsoluteUriPath(uri);

            _loader   = new WebRequestLoader(directoryPath);
            _fileName = URIHelper.GetFileFromUri(uri);

            LoadScene(SceneIndex);
        }
        void Start()
        {
            Debug.Log("Hit spacebar to change the scene.");

            Uri uri           = new Uri(Url);
            var directoryPath = URIHelper.AbsoluteUriPath(uri);

            _loader   = new WebRequestLoader(directoryPath);
            _fileName = URIHelper.GetFileFromUri(uri);

            StartCoroutine(LoadScene(SceneIndex));
        }
Beispiel #5
0
        IEnumerator Start()
        {
            ILoader loader        = new WebRequestLoader(URIHelper.GetDirectoryName(Url));
            var     sceneImporter = new GLTFSceneImporter(
                URIHelper.GetFileFromUri(new Uri(Url)),
                loader
                );

            sceneImporter.SceneParent = gameObject.transform;
            yield return(sceneImporter.LoadScene(-1, Multithreaded));

            IntegrationTest.Pass();
        }
Beispiel #6
0
        private async Task <IList <Asset> > LoadAssetsFromGLTF(AssetSource source, Guid containerId, ColliderType colliderType)
        {
            WebRequestLoader loader = null;
            Stream           stream = null;

            source.ParsedUri = new Uri(_app.ServerAssetUri, source.ParsedUri);
            var rootUri       = URIHelper.GetDirectoryName(source.ParsedUri.AbsoluteUri);
            var cachedVersion = MREAPI.AppsAPI.AssetCache.SupportsSync ?
                                MREAPI.AppsAPI.AssetCache.GetVersionSync(source.ParsedUri) :
                                await MREAPI.AppsAPI.AssetCache.GetVersion(source.ParsedUri);

            // Wait asynchronously until the load throttler lets us through.
            using (var scope = await AssetLoadThrottling.AcquireLoadScope())
            {
                // set up loader
                loader = new WebRequestLoader(rootUri);
                if (!string.IsNullOrEmpty(cachedVersion))
                {
                    loader.BeforeRequestCallback += (msg) =>
                    {
                        if (msg.RequestUri == source.ParsedUri)
                        {
                            msg.Headers.Add("If-None-Match", cachedVersion);
                        }
                    };
                }

                // download root gltf file, check for cache hit
                try
                {
                    stream = await loader.LoadStreamAsync(URIHelper.GetFileFromUri(source.ParsedUri));

                    source.Version = loader.LastResponse.Headers.ETag?.Tag ?? "";
                }
                catch (HttpRequestException)
                {
                    if (loader.LastResponse.StatusCode == System.Net.HttpStatusCode.NotModified)
                    {
                        source.Version = cachedVersion;
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            IList <Asset>      assetDefs     = new List <Asset>(30);
            DeterministicGuids guidGenerator = new DeterministicGuids(UtilMethods.StringToGuid(
                                                                          $"{containerId}:{source.ParsedUri.AbsoluteUri}"));
            IList <UnityEngine.Object> assets;

            // fetch assets from glTF stream or cache
            if (source.Version != cachedVersion)
            {
                assets = await LoadGltfFromStream(loader, stream, colliderType);

                MREAPI.AppsAPI.AssetCache.StoreAssets(source.ParsedUri, assets, source.Version);
            }
            else
            {
                var assetsEnum = MREAPI.AppsAPI.AssetCache.SupportsSync ?
                                 MREAPI.AppsAPI.AssetCache.LeaseAssetsSync(source.ParsedUri) :
                                 await MREAPI.AppsAPI.AssetCache.LeaseAssets(source.ParsedUri);

                assets = assetsEnum.ToList();
            }

            // catalog assets
            int textureIndex = 0, meshIndex = 0, materialIndex = 0, prefabIndex = 0;

            foreach (var asset in assets)
            {
                var assetDef = GenerateAssetPatch(asset, guidGenerator.Next());
                assetDef.Name = asset.name;

                string internalId = null;
                if (asset is UnityEngine.Texture)
                {
                    internalId = $"texture:{textureIndex++}";
                }
                else if (asset is UnityEngine.Mesh)
                {
                    internalId = $"mesh:{meshIndex++}";
                }
                else if (asset is UnityEngine.Material)
                {
                    internalId = $"material:{materialIndex++}";
                }
                else if (asset is GameObject)
                {
                    internalId = $"scene:{prefabIndex++}";
                }
                assetDef.Source = new AssetSource(source.ContainerType, source.ParsedUri.AbsoluteUri, internalId, source.Version);

                ColliderGeometry colliderGeo = null;
                if (asset is UnityEngine.Mesh mesh)
                {
                    colliderGeo = colliderType == ColliderType.Mesh ?
                                  (ColliderGeometry) new MeshColliderGeometry()
                    {
                        MeshId = assetDef.Id
                    } :
                    (ColliderGeometry) new BoxColliderGeometry()
                    {
                        Size   = (mesh.bounds.size * 0.8f).CreateMWVector3(),
                        Center = mesh.bounds.center.CreateMWVector3()
                    };
                }

                _app.AssetManager.Set(assetDef.Id, containerId, asset, colliderGeo, assetDef.Source);
                assetDefs.Add(assetDef);
            }

            return(assetDefs);
        }
Beispiel #7
0
        private async Task <IList <Asset> > LoadAssetsFromGLTF(AssetSource source, Guid containerId, ColliderType colliderType)
        {
            IList <Asset>      assets        = new List <Asset>();
            DeterministicGuids guidGenerator = new DeterministicGuids(UtilMethods.StringToGuid(
                                                                          $"{containerId}:{source.ParsedUri.AbsoluteUri}"));

            // download file
            var rootUrl = URIHelper.GetDirectoryName(source.ParsedUri.AbsoluteUri);
            var loader  = new WebRequestLoader(rootUrl);
            var stream  = await loader.LoadStreamAsync(URIHelper.GetFileFromUri(source.ParsedUri));

            // pre-parse glTF document so we can get a scene count
            // TODO: run this in thread
            GLTF.GLTFParser.ParseJson(stream, out GLTF.Schema.GLTFRoot gltfRoot);
            stream.Position = 0;

            GLTFSceneImporter importer =
                MREAPI.AppsAPI.GLTFImporterFactory.CreateImporter(gltfRoot, loader, _asyncHelper, stream);

            importer.SceneParent = MREAPI.AppsAPI.AssetCache.CacheRootGO().transform;
            importer.Collider    = colliderType.ToGLTFColliderType();

            // load textures
            if (gltfRoot.Textures != null)
            {
                for (var i = 0; i < gltfRoot.Textures.Count; i++)
                {
                    await importer.LoadTextureAsync(gltfRoot.Textures[i], i, true);

                    var texture = importer.GetTexture(i);
                    texture.name = gltfRoot.Textures[i].Name ?? $"texture:{i}";

                    var asset = GenerateAssetPatch(texture, guidGenerator.Next());
                    asset.Name   = texture.name;
                    asset.Source = new AssetSource(source.ContainerType, source.Uri, $"texture:{i}");
                    MREAPI.AppsAPI.AssetCache.CacheAsset(texture, asset.Id, containerId, source);
                    assets.Add(asset);
                }
            }

            // load meshes
            if (gltfRoot.Meshes != null)
            {
                var cancellationSource = new System.Threading.CancellationTokenSource();
                for (var i = 0; i < gltfRoot.Meshes.Count; i++)
                {
                    var mesh = await importer.LoadMeshAsync(i, cancellationSource.Token);

                    mesh.name = gltfRoot.Meshes[i].Name ?? $"mesh:{i}";

                    var asset = GenerateAssetPatch(mesh, guidGenerator.Next());
                    asset.Name   = mesh.name;
                    asset.Source = new AssetSource(source.ContainerType, source.Uri, $"mesh:{i}");
                    var colliderGeo = colliderType == ColliderType.Mesh ?
                                      (ColliderGeometry) new MeshColliderGeometry()
                    {
                        MeshId = asset.Id
                    } :
                    (ColliderGeometry) new BoxColliderGeometry()
                    {
                        Size = (mesh.bounds.size * 0.8f).CreateMWVector3()
                    };
                    MREAPI.AppsAPI.AssetCache.CacheAsset(mesh, asset.Id, containerId, source, colliderGeo);
                    assets.Add(asset);
                }
            }

            // load materials
            if (gltfRoot.Materials != null)
            {
                for (var i = 0; i < gltfRoot.Materials.Count; i++)
                {
                    var matdef   = gltfRoot.Materials[i];
                    var material = await importer.LoadMaterialAsync(i);

                    material.name = matdef.Name ?? $"material:{i}";

                    var asset = GenerateAssetPatch(material, guidGenerator.Next());
                    asset.Name   = material.name;
                    asset.Source = new AssetSource(source.ContainerType, source.Uri, $"material:{i}");
                    MREAPI.AppsAPI.AssetCache.CacheAsset(material, asset.Id, containerId, source);
                    assets.Add(asset);
                }
            }

            // load prefabs
            if (gltfRoot.Scenes != null)
            {
                for (var i = 0; i < gltfRoot.Scenes.Count; i++)
                {
                    await importer.LoadSceneAsync(i).ConfigureAwait(true);

                    GameObject rootObject = importer.LastLoadedScene;
                    rootObject.name = gltfRoot.Scenes[i].Name ?? $"scene:{i}";

                    var animation = rootObject.GetComponent <UnityEngine.Animation>();
                    if (animation != null)
                    {
                        animation.playAutomatically = false;

                        // initialize mapping so we know which gameobjects are targeted by which animation clips
                        var mapping = rootObject.AddComponent <PrefabAnimationTargets>();
                        mapping.Initialize(gltfRoot, i);
                    }

                    MWGOTreeWalker.VisitTree(rootObject, (go) =>
                    {
                        go.layer = MREAPI.AppsAPI.LayerApplicator.DefaultLayer;
                    });

                    var def = GenerateAssetPatch(rootObject, guidGenerator.Next());
                    def.Name   = rootObject.name;
                    def.Source = new AssetSource(source.ContainerType, source.Uri, $"scene:{i}");
                    MREAPI.AppsAPI.AssetCache.CacheAsset(rootObject, def.Id, containerId, source);
                    assets.Add(def);
                }
            }

            importer.Dispose();

            return(assets);
        }