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));
}
private GameObject CreateGLTFScene(string projectFilePath)
{
ILoader fileLoader = new FileLoader(Path.GetDirectoryName(projectFilePath));
; using (var stream = File.OpenRead(projectFilePath))
{
GLTFRoot gLTFRoot = GLTFParser.ParseJson(stream);
var loader = new GLTFSceneImporter(gLTFRoot, fileLoader, stream);
loader.MaximumLod = _maximumLod;
// HACK: Force the coroutine to run synchronously in the editor
var stack = new Stack <IEnumerator>();
stack.Push(loader.LoadScene(isMultithreaded: true));
while (stack.Count > 0)
{
var enumerator = stack.Pop();
if (enumerator.MoveNext())
{
stack.Push(enumerator);
var subEnumerator = enumerator.Current as IEnumerator;
if (subEnumerator != null)
{
stack.Push(subEnumerator);
}
}
}
return(loader.LastLoadedScene);
}
}
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;
}
}
}
// 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));
}
public IEnumerator Load(Action CompleteCallback)
{
GLTFSceneImporter loader = null;
FileStream gltfStream = null;
if (UseStream)
{
var fullPath = Application.streamingAssetsPath + Url;
gltfStream = File.OpenRead(fullPath);
Stream str = gltfStream;
#if TESTING
MemoryStream ms = new MemoryStream();
var br = new BinaryReader(gltfStream);
var str = Convert.ToBase64String(br.ReadBytes((int)gltfStream.Length));
// Return a fixed model in byte array format..
var ba = Convert.FromBase64String(str);
var msw = new BinaryWriter(ms);
msw.Write(ba);
ms.Position = 0;
str = ms;
#endif
loader = new GLTFSceneImporter(
fullPath,
str,
gameObject.transform,
addColliders
);
}
else
{
loader = new GLTFSceneImporter(
Url,
gameObject.transform,
addColliders
);
}
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.PbrMetallicRoughness, GLTFStandard);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.KHR_materials_pbrSpecularGlossiness, GLTFStandardSpecular);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.CommonConstant, GLTFConstant);
loader.MaximumLod = MaximumLod;
yield return(loader.Load(-1, Multithreaded));
CompleteCallback();
if (gltfStream != null)
{
#if WINDOWS_UWP
gltfStream.Dispose();
#else
gltfStream.Close();
#endif
}
}
IEnumerator Start()
{
GLTFSceneImporter loader = null;
if (UseStream)
{
string fullPath = "";
if (GLTFStream == null)
{
fullPath = Path.Combine(Application.streamingAssetsPath, Url);
GLTFStream = File.OpenRead(fullPath);
}
loader = new GLTFSceneImporter(
fullPath,
GLTFStream,
gameObject.transform,
addColliders
);
}
else
{
loader = new GLTFSceneImporter(
Url,
gameObject.transform,
addColliders
);
}
//MENTOR ALERT!
//TODO: this may be in violation of the rules because you are editing a script you did not right. REMOVE
EachHand e = gameObject.AddComponent <EachHand> ();
e.gazeControl = GameObject.Find("MixedRealityCameraParent").GetComponent <SimpleGazeControl> ();
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.PbrMetallicRoughness, GLTFStandard);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.KHR_materials_pbrSpecularGlossiness, GLTFStandardSpecular);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.CommonConstant, GLTFConstant);
loader.MaximumLod = MaximumLod;
yield return(loader.Load(-1, Multithreaded));
if (GLTFStream != null)
{
#if WINDOWS_UWP
GLTFStream.Dispose();
#else
GLTFStream.Close();
#endif
GLTFStream = null;
}
IsLoaded = true;
}
private GameObject CreateGLTFScene(string projectFilePath)
{
ILoader fileLoader = new FileLoader(Path.GetDirectoryName(projectFilePath));
using (var stream = File.OpenRead(projectFilePath))
{
GLTFRoot gLTFRoot;
GLTFParser.ParseJson(stream, out gLTFRoot);
OnGLTFRootIsConstructed?.Invoke(gLTFRoot);
var loader = new GLTFSceneImporter(Path.GetFullPath(projectFilePath), gLTFRoot, fileLoader, null, stream);
GLTFSceneImporter.budgetPerFrameInMilliseconds = float.MaxValue;
loader.addImagesToPersistentCaching = false; // Since we control the PersistentAssetCache during AB Conversion, we don't want the importer to mess with that
loader.addMaterialsToPersistentCaching = false;
loader.initialVisibility = true;
loader.useMaterialTransition = false;
loader.maximumLod = _maximumLod;
loader.isMultithreaded = true;
OnGLTFWillLoad?.Invoke(loader);
// HACK: Force the coroutine to run synchronously in the editor
var stack = new Stack <IEnumerator>();
stack.Push(loader.LoadScene());
while (stack.Count > 0)
{
var enumerator = stack.Pop();
try
{
if (enumerator.MoveNext())
{
stack.Push(enumerator);
var subEnumerator = enumerator.Current as IEnumerator;
if (subEnumerator != null)
{
stack.Push(subEnumerator);
}
}
}
catch (Exception e)
{
Debug.Log("GLTFImporter - CreateGLTFScene Failed: " + e.Message + "\n" + e.StackTrace);
}
}
return(loader.lastLoadedScene);
}
}
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;
}
}
}
IEnumerator Start()
{
GLTFSceneImporter loader = null;
if (UseStream)
{
string fullPath = "";
if (GLTFStream == null)
{
fullPath = Path.Combine(Application.streamingAssetsPath, Url);
GLTFStream = File.OpenRead(fullPath);
}
loader = new GLTFSceneImporter(
fullPath,
GLTFStream,
gameObject.transform,
addColliders
);
}
else
{
loader = new GLTFSceneImporter(
Url,
gameObject.transform,
addColliders
);
}
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.PbrMetallicRoughness, GLTFStandard);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.KHR_materials_pbrSpecularGlossiness, GLTFStandardSpecular);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.CommonConstant, GLTFConstant);
loader.MaximumLod = MaximumLod;
yield return(loader.Load(-1, Multithreaded));
if (GLTFStream != null)
{
#if WINDOWS_UWP
GLTFStream.Dispose();
#else
GLTFStream.Close();
#endif
GLTFStream = null;
}
IsLoaded = true;
}
private GameObject CreateGLTFScene(string projectFilePath)
{
ILoader fileLoader = new FileLoader(Path.GetDirectoryName(projectFilePath));
using (var stream = File.OpenRead(projectFilePath))
{
GLTFRoot gLTFRoot;
GLTFParser.ParseJson(stream, out gLTFRoot);
var loader = new GLTFSceneImporter(gLTFRoot, fileLoader, null, stream);
loader.MaximumLod = _maximumLod;
loader.IsMultithreaded = true;
loader.LoadSceneAsync().Wait();
return(loader.LastLoadedScene);
}
}
private GameObject CreateGLTFScene(string projectFilePath)
{
var importOptions = new ImportOptions
{
DataLoader = new FileLoader(Path.GetDirectoryName(projectFilePath)),
};
using (var stream = File.OpenRead(projectFilePath))
{
GLTFRoot gLTFRoot;
GLTFParser.ParseJson(stream, out gLTFRoot);
stream.Position = 0; // Make sure the read position is changed back to the beginning of the file
var loader = new GLTFSceneImporter(gLTFRoot, stream, importOptions);
loader.MaximumLod = _maximumLod;
loader.IsMultithreaded = true;
loader.LoadSceneAsync().Wait();
return(loader.LastLoadedScene);
}
}
private GameObject CreateGLTFScene(string projectFilePath)
{
ILoader fileLoader = new FileLoader(Path.GetDirectoryName(projectFilePath));
using (var stream = File.OpenRead(projectFilePath))
{
GLTFRoot gLTFRoot;
GLTFParser.ParseJson(stream, out gLTFRoot);
OnGLTFRootIsConstructed?.Invoke(gLTFRoot);
var loader = new GLTFSceneImporter(Path.GetFullPath(projectFilePath), gLTFRoot, fileLoader, null, stream);
GLTFSceneImporter.budgetPerFrameInMilliseconds = float.MaxValue;
loader.addImagesToPersistentCaching = false;
loader.addMaterialsToPersistentCaching = false;
loader.initialVisibility = true;
loader.useMaterialTransition = false;
loader.maximumLod = _maximumLod;
loader.isMultithreaded = true;
// HACK: Force the coroutine to run synchronously in the editor
var stack = new Stack <IEnumerator>();
stack.Push(loader.LoadScene());
while (stack.Count > 0)
{
var enumerator = stack.Pop();
if (enumerator.MoveNext())
{
stack.Push(enumerator);
var subEnumerator = enumerator.Current as IEnumerator;
if (subEnumerator != null)
{
stack.Push(subEnumerator);
}
}
}
return(loader.lastLoadedScene);
}
}
IEnumerator Start()
{
GLTFSceneImporter loader = null;
FileStream gltfStream = null;
if (UseStream)
{
var fullPath = Path.Combine(Application.streamingAssetsPath, Url);
gltfStream = File.OpenRead(fullPath);
loader = new GLTFSceneImporter(
fullPath,
gltfStream,
gameObject.transform,
Colliders
);
}
else
{
loader = new GLTFSceneImporter(
Url,
gameObject.transform,
Colliders
);
}
loader.MaximumLod = MaximumLod;
yield return(loader.Load(-1, Multithreaded));
if (gltfStream != null)
{
#if WINDOWS_UWP
gltfStream.Dispose();
#else
gltfStream.Close();
#endif
}
}
IEnumerator Start()
{
GLTFSceneImporter loader = null;
FileStream gltfStream = null;
if (UseStream)
{
var fullPath = Application.streamingAssetsPath + Url;
gltfStream = File.OpenRead(fullPath);
loader = new GLTFSceneImporter(
fullPath,
gltfStream,
gameObject.transform
);
}
else
{
loader = new GLTFSceneImporter(
Url,
gameObject.transform
);
}
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.PbrMetallicRoughness, GLTFStandard);
loader.SetShaderForMaterialType(GLTFSceneImporter.MaterialType.CommonConstant, GLTFConstant);
loader.MaximumLod = MaximumLod;
yield return(loader.Load(-1, Multithreaded));
if (gltfStream != null)
{
#if WINDOWS_UWP
gltfStream.Dispose();
#else
gltfStream.Close();
#endif
}
}
// 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);
}
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;
}
}
}
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);
}
}
}
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);
}
