Beispiel #1
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));
        }
Beispiel #2
0
        public IEnumerator Load()
        {
            GLTFSceneImporter sceneImporter = null;
            ILoader           loader        = null;

            try
            {
                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         = Collider;
                sceneImporter.MaximumLod       = MaximumLod;
                sceneImporter.Timeout          = Timeout;
                sceneImporter.isMultithreaded  = Multithreaded;
                sceneImporter.CustomShaderName = shaderOverride ? shaderOverride.name : null;
                yield return(sceneImporter.LoadScene(-1));

                // Override the shaders on all materials if a shader is provided
                if (shaderOverride != null)
                {
                    Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
                    foreach (Renderer renderer in renderers)
                    {
                        renderer.sharedMaterial.shader = shaderOverride;
                    }
                }
            }
            finally
            {
                if (loader != null)
                {
                    sceneImporter.Dispose();
                    sceneImporter = null;
                    loader        = null;
                }
            }
        }
Beispiel #3
0
        // todo undo
#if !WINDOWS_UWP
        IEnumerator Start()
        {
            var     fullPath0 = Application.streamingAssetsPath + Path.DirectorySeparatorChar + asset0Path;
            ILoader loader0   = new FileLoader(URIHelper.GetDirectoryName(fullPath0));

            var     fullPath1 = Application.streamingAssetsPath + Path.DirectorySeparatorChar + asset1Path;
            ILoader loader1   = new FileLoader(URIHelper.GetDirectoryName(fullPath1));

            yield return(loader0.LoadStream(Path.GetFileName(asset0Path)));

            var asset0Stream = loader0.LoadedStream;
            var asset0Root   = GLTFParser.ParseJson(asset0Stream);

            yield return(loader1.LoadStream(Path.GetFileName(asset1Path)));

            var asset1Stream = loader1.LoadedStream;
            var asset1Root   = GLTFParser.ParseJson(asset1Stream);

            string newPath = "../../" + URIHelper.GetDirectoryName(asset0Path);

            int previousBufferCount  = asset1Root.Buffers.Count;
            int previousImageCount   = asset1Root.Images.Count;
            int previousSceneCounter = asset1Root.Scenes.Count;

            GLTFHelpers.MergeGLTF(asset1Root, asset0Root);

            for (int i = previousBufferCount; i < asset1Root.Buffers.Count; ++i)
            {
                GLTF.Schema.Buffer buffer = asset1Root.Buffers[i];
                if (!URIHelper.IsBase64Uri(buffer.Uri))
                {
                    buffer.Uri = newPath + buffer.Uri;
                }
            }

            for (int i = previousImageCount; i < asset1Root.Images.Count; ++i)
            {
                Image image = asset1Root.Images[i];
                if (!URIHelper.IsBase64Uri(image.Uri))
                {
                    image.Uri = newPath + image.Uri;
                }
            }

            foreach (NodeId node in asset1Root.Scenes[asset0Root.Scene.Id + previousSceneCounter].Nodes)
            {
                node.Value.Translation.X += 5f;
                asset1Root.Scene.Value.Nodes.Add(node);
            }
            GLTFSceneImporter importer = new GLTFSceneImporter(
                asset1Root,
                loader1
                );

            importer.MaximumLod = MaximumLod;

            yield return(importer.LoadScene(-1, Multithreaded));
        }
Beispiel #4
0
        public IEnumerator Load()
        {
            GLTFSceneImporter sceneImporter = null;
            ILoader           loader        = null;

            try
            {
                string directoryPath = URIHelper.GetDirectoryName(GLTFUri);
                loader        = new WebRequestLoader(directoryPath);
                sceneImporter = new GLTFSceneImporter(
                    URIHelper.GetFileFromUri(new Uri(GLTFUri)),
                    loader
                    );

                sceneImporter.SceneParent      = gameObject.transform;
                sceneImporter.Collider         = Collider;
                sceneImporter.MaximumLod       = MaximumLod;
                sceneImporter.Timeout          = Timeout;
                sceneImporter.isMultithreaded  = Multithreaded;
                sceneImporter.CustomShaderName = shaderOverride ? shaderOverride.name : null;
                yield return(sceneImporter.LoadScene(-1));

                // Override the shaders on all materials if a shader is provided
                if (shaderOverride != null)
                {
                    Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
                    foreach (Renderer renderer in renderers)
                    {
                        renderer.sharedMaterial.shader = shaderOverride;
                    }
                }

                if (gameObject.GetComponentInChildren <Animation>() != null)
                {
                    anim = gameObject.GetComponentInChildren <Animation>();
                }
                if (anim != null)
                {
                    anim.Play();
                }
            }
            finally
            {
                if (loader != null)
                {
                    sceneImporter.Dispose();
                    sceneImporter = null;
                    loader        = null;
                }
            }
        }
Beispiel #5
0
        // todo undo
#if !WINDOWS_UWP
        private async Task Start()
        {
            var         fullPath0 = Application.streamingAssetsPath + Path.DirectorySeparatorChar + asset0Path;
            IDataLoader loader0   = new FileLoader(URIHelper.GetDirectoryName(fullPath0));

            var         fullPath1 = Application.streamingAssetsPath + Path.DirectorySeparatorChar + asset1Path;
            IDataLoader loader1   = new FileLoader(URIHelper.GetDirectoryName(fullPath1));

            var asset0Stream = await loader0.LoadStreamAsync(Path.GetFileName(asset0Path));

            GLTFRoot asset0Root;

            GLTFParser.ParseJson(asset0Stream, out asset0Root);

            var asset1Stream = await loader1.LoadStreamAsync(Path.GetFileName(asset1Path));

            GLTFRoot asset1Root;

            GLTFParser.ParseJson(asset1Stream, out asset1Root);

            string newPath = "../../" + URIHelper.GetDirectoryName(asset0Path);

            int previousBufferCount  = asset1Root.Buffers.Count;
            int previousImageCount   = asset1Root.Images.Count;
            int previousSceneCounter = asset1Root.Scenes.Count;

            GLTFHelpers.MergeGLTF(asset1Root, asset0Root);

            for (int i = previousBufferCount; i < asset1Root.Buffers.Count; ++i)
            {
                GLTF.Schema.GLTFBuffer buffer = asset1Root.Buffers[i];
                if (!URIHelper.IsBase64Uri(buffer.Uri))
                {
                    buffer.Uri = newPath + buffer.Uri;
                }
            }

            for (int i = previousImageCount; i < asset1Root.Images.Count; ++i)
            {
                GLTFImage image = asset1Root.Images[i];
                if (!URIHelper.IsBase64Uri(image.Uri))
                {
                    image.Uri = newPath + image.Uri;
                }
            }

            foreach (NodeId node in asset1Root.Scenes[asset0Root.Scene.Id + previousSceneCounter].Nodes)
            {
                node.Value.Translation.X += 5f;
                asset1Root.Scene.Value.Nodes.Add(node);
            }
            GLTFSceneImporter importer = new GLTFSceneImporter(
                asset1Root,
                null,
                new ImportOptions
            {
                DataLoader           = loader1,
                AsyncCoroutineHelper = gameObject.AddComponent <AsyncCoroutineHelper>()
            });

            importer.MaximumLod      = MaximumLod;
            importer.IsMultithreaded = Multithreaded;
            await importer.LoadSceneAsync(-1);
        }
Beispiel #6
0
        public async Task Load()
        {
            asyncCoroutineHelper = gameObject.GetComponent <AsyncCoroutineHelper>() ?? gameObject.AddComponent <AsyncCoroutineHelper>();
            GLTFSceneImporter sceneImporter = null;
            ILoader           loader        = null;

            try
            {
                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;
                    if (AppendStreamingAssets)
                    {
                        fullPath = Path.Combine(Application.streamingAssetsPath, GLTFUri);
                    }
                    else
                    {
                        fullPath = GLTFUri;
                    }
                    string directoryPath = URIHelper.GetDirectoryName(fullPath);
                    loader        = new FileLoader(directoryPath);
                    sceneImporter = new GLTFSceneImporter(
                        Path.GetFileName(GLTFUri),
                        loader,
                        asyncCoroutineHelper
                        );
                }
                else
                {
                    string directoryPath = URIHelper.GetDirectoryName(GLTFUri);
                    loader = new WebRequestLoader(directoryPath);

                    sceneImporter = new GLTFSceneImporter(
                        URIHelper.GetFileFromUri(new Uri(GLTFUri)),
                        loader,
                        asyncCoroutineHelper
                        );
                }

                sceneImporter.SceneParent      = gameObject.transform;
                sceneImporter.Collider         = Collider;
                sceneImporter.MaximumLod       = MaximumLod;
                sceneImporter.Timeout          = Timeout;
                sceneImporter.isMultithreaded  = Multithreaded;
                sceneImporter.CustomShaderName = shaderOverride ? shaderOverride.name : null;

                if (MaterialsOnly)
                {
                    var mat = await sceneImporter.LoadMaterialAsync(0);

                    var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    cube.transform.SetParent(gameObject.transform);
                    var renderer = cube.GetComponent <Renderer>();
                    renderer.sharedMaterial = mat;
                }
                else
                {
                    await sceneImporter.LoadSceneAsync();
                }

                // Override the shaders on all materials if a shader is provided
                if (shaderOverride != null)
                {
                    Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
                    foreach (Renderer renderer in renderers)
                    {
                        renderer.sharedMaterial.shader = shaderOverride;
                    }
                }

                if (PlayAnimationOnLoad)
                {
                    Animation[] animations = sceneImporter.LastLoadedScene.GetComponents <Animation>();
                    foreach (Animation anim in animations)
                    {
                        anim.Play();
                    }
                }
            }
            finally
            {
                if (loader != null)
                {
                    sceneImporter?.Dispose();
                    sceneImporter = null;
                    loader        = null;
                }
            }
        }
Beispiel #7
0
        public async Task Load()
        {
            var importOptions = new ImportOptions
            {
                AsyncCoroutineHelper = gameObject.GetComponent <AsyncCoroutineHelper>() ?? gameObject.AddComponent <AsyncCoroutineHelper>()
            };

            GLTFSceneImporter sceneImporter = null;

            try
            {
                Factory = Factory ?? ScriptableObject.CreateInstance <DefaultImporterFactory>();

                if (UseStream)
                {
                    string fullPath;
                    if (AppendStreamingAssets)
                    {
                        // 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.
                        fullPath = Path.Combine(Application.streamingAssetsPath, GLTFUri.TrimStart(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }));
                    }
                    else
                    {
                        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      = gameObject.transform;
                sceneImporter.Collider         = Collider;
                sceneImporter.MaximumLod       = MaximumLod;
                sceneImporter.Timeout          = Timeout;
                sceneImporter.IsMultithreaded  = Multithreaded;
                sceneImporter.CustomShaderName = shaderOverride ? shaderOverride.name : null;

                if (MaterialsOnly)
                {
                    var mat = await sceneImporter.LoadMaterialAsync(0);

                    var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                    cube.transform.SetParent(gameObject.transform);
                    var renderer = cube.GetComponent <Renderer>();
                    renderer.sharedMaterial = mat;
                }
                else
                {
                    await sceneImporter.LoadSceneAsync();
                }

                // Override the shaders on all materials if a shader is provided
                if (shaderOverride != null)
                {
                    Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
                    foreach (Renderer renderer in renderers)
                    {
                        renderer.sharedMaterial.shader = shaderOverride;
                    }
                }

                print("model loaded with vertices: " + sceneImporter.Statistics.VertexCount.ToString() + ", triangles: " + sceneImporter.Statistics.TriangleCount.ToString());
                LastLoadedScene = sceneImporter.LastLoadedScene;

                Animations = sceneImporter.LastLoadedScene.GetComponents <Animation>();

                if (PlayAnimationOnLoad && Animations.Any())
                {
                    Animations.FirstOrDefault().Play();
                }
            }
            finally
            {
                if (importOptions.DataLoader != null)
                {
                    sceneImporter?.Dispose();
                    sceneImporter            = null;
                    importOptions.DataLoader = null;
                }

                if (onLoadFinished != null)
                {
                    onLoadFinished.Invoke(this);
                }

                if (loadingIndicaor)
                {
                    loadingIndicaor.SetActive(false);
                }
            }
        }
Beispiel #8
0
        public IEnumerator LoadAssetCoroutine()
        {
            if (!string.IsNullOrEmpty(GLTFUri))
            {
                if (VERBOSE)
                {
                    Debug.Log("LoadAssetCoroutine() GLTFUri ->" + GLTFUri);
                }

                asyncCoroutineHelper = gameObject.GetComponent <AsyncCoroutineHelper>() ?? gameObject.AddComponent <AsyncCoroutineHelper>();

                sceneImporter = null;
                ILoader loader = null;

                Destroy(loadedAssetRootGameObject);

                try
                {
                    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,
                            asyncCoroutineHelper
                            );
                    }
                    else
                    {
                        loader = new WebRequestLoader("");

                        if (OnWebRequestStartEvent != null)
                        {
                            (loader as WebRequestLoader).OnLoadStreamStart += OnWebRequestStartEvent;
                        }

                        sceneImporter = new GLTFSceneImporter(
                            GLTFUri,
                            loader,
                            asyncCoroutineHelper
                            );
                    }

                    if (sceneImporter.CreatedObject != null)
                    {
                        Destroy(sceneImporter.CreatedObject);
                    }

                    sceneImporter.SceneParent                     = gameObject.transform;
                    sceneImporter.Collider                        = Collider;
                    sceneImporter.maximumLod                      = MaximumLod;
                    sceneImporter.Timeout                         = Timeout;
                    sceneImporter.isMultithreaded                 = Multithreaded;
                    sceneImporter.useMaterialTransition           = UseVisualFeedback;
                    sceneImporter.CustomShaderName                = shaderOverride ? shaderOverride.name : null;
                    sceneImporter.LoadingTextureMaterial          = LoadingTextureMaterial;
                    sceneImporter.initialVisibility               = initialVisibility;
                    sceneImporter.addMaterialsToPersistentCaching = addMaterialsToPersistentCaching;

                    float time = Time.realtimeSinceStartup;

                    queueCount++;

                    state = State.QUEUED;

                    Func <bool> funcTestDistance = () => TestDistance();
                    yield return(new WaitUntil(funcTestDistance));

                    queueCount--;
                    totalDownloadedCount++;

                    IncrementDownloadCount();

                    state = State.DOWNLOADING;

                    yield return(sceneImporter.LoadScene(-1));

                    state = State.COMPLETED;

                    DecrementDownloadCount();

                    // Override the shaders on all materials if a shader is provided
                    if (shaderOverride != null)
                    {
                        Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
                        foreach (Renderer renderer in renderers)
                        {
                            renderer.sharedMaterial.shader = shaderOverride;
                        }
                    }
                }
                finally
                {
                    if (loader != null)
                    {
                        if (sceneImporter == null)
                        {
                            Debug.Log("sceneImporter is null, could be due to an invalid URI.", this);
                        }
                        else
                        {
                            loadedAssetRootGameObject = sceneImporter.CreatedObject;

                            sceneImporter?.Dispose();
                            sceneImporter = null;
                        }

                        if (OnWebRequestStartEvent != null)
                        {
                            (loader as WebRequestLoader).OnLoadStreamStart -= OnWebRequestStartEvent;
                            OnWebRequestStartEvent = null;
                        }

                        loader = null;
                    }

                    alreadyLoadedAsset = true;
                    OnFinishedLoadingAsset?.Invoke();
                }
            }
            else
            {
                Debug.Log("couldn't load GLTF because url is empty");
            }

            CoroutineStarter.Stop(loadingRoutine);
            loadingRoutine = null;
            Destroy(loadingPlaceholder);
            Destroy(this);
        }