async Task LoadGltfSampleSetItem(SampleSetItem testCase, GameObject go, IDeferAgent deferAgent, SampleGroup loadTime = null)
{
var path = string.Format(
#if UNITY_ANDROID && !UNITY_EDITOR
"{0}"
#else
"file://{0}"
#endif
, testCase.path
);
// Debug.LogFormat("Testing {0}", path);
var gltfAsset = go.AddComponent <GltfAsset>();
var stopWatch = go.AddComponent <StopWatch>();
stopWatch.StartTime();
gltfAsset.loadOnStartup = false;
var success = await gltfAsset.Load(path, null, deferAgent);
Assert.IsTrue(success);
stopWatch.StopTime();
if (loadTime != null)
{
Measure.Custom(loadTime, stopWatch.lastDuration);
}
}
public override async Task <bool> Load(
string url,
IDownloadProvider downloadProvider = null,
IDeferAgent deferAgent = null,
IMaterialGenerator materialGenerator = null,
ICodeLogger logger = null
)
{
logger = logger ?? new ConsoleLogger();
var success = await base.Load(url, downloadProvider, deferAgent, materialGenerator, logger);
if (success)
{
if (deferAgent != null)
{
await deferAgent.BreakPoint();
}
// Auto-Instantiate
if (sceneId >= 0)
{
InstantiateScene(sceneId, logger);
}
else
{
Instantiate(logger);
}
}
return(success);
}
public override async Task <bool> Load(
string url,
IDownloadProvider downloadProvider = null,
IDeferAgent deferAgent = null,
IMaterialGenerator materialGenerator = null,
ILogger logger = null
)
{
importer = new GltfImport(downloadProvider, deferAgent, materialGenerator);
var success = await importer.Load(url);
if (success)
{
var insta = (GameObjectBoundsInstantiator)GetDefaultInstantiator(logger);
// Auto-Instantiate
if (sceneId >= 0)
{
success = importer.InstantiateScene(insta, sceneId);
}
else
{
success = importer.InstantiateMainScene(insta);
}
if (success)
{
SetBounds(insta);
}
}
return(success);
}
void Load(IDeferAgent deferAgent = null)
{
gLTFastInstance = new GLTFast(this);
gLTFastInstance.onSettingRequest += OnSettingHeaders;
gLTFastInstance.onLoadComplete += OnLoadComplete;
gLTFastInstance.Load(url, deferAgent, _forceBinary);
}
/// <summary>
/// Provides glTF export of GameObject based scenes and hierarchies.
/// </summary>
/// <param name="exportSettings">Export settings</param>
/// <param name="deferAgent">Defer agent; decides when/if to preempt
/// export to preserve a stable frame rate <seealso cref="IDeferAgent"/></param>
/// <param name="logger">Interface for logging (error) messages
/// <seealso cref="ConsoleLogger"/></param>
public GameObjectExport(
ExportSettings exportSettings = null,
IDeferAgent deferAgent = null,
ICodeLogger logger = null
)
{
m_Writer = new GltfWriter(exportSettings, deferAgent, logger);
}
public MorphTargetsContext(int morphTargetCount, string[] meshTargetNames, IDeferAgent deferAgent)
{
contexts = new MorphTargetContext[morphTargetCount];
handles = new NativeArray <JobHandle>(morphTargetCount, VertexBufferConfigBase.defaultAllocator);
currentIndex = 0;
this.meshTargetNames = meshTargetNames;
this.deferAgent = deferAgent;
}
public void Load(string url = null, IDeferAgent deferAgent = null)
{
if (url != null)
{
this.url = url;
}
gLTFastInstance = new GLTFast(this);
gLTFastInstance.onLoadComplete += OnLoadComplete;
gLTFastInstance.Load(this.url, deferAgent);
}
/// <summary>
/// Method for manual loading with custom <see cref="IDownloadProvider"/> and <see cref="IDeferAgent"/>.
/// </summary>
/// <param name="url">URL of the glTF file.</param>
/// <param name="downloadProvider">Download Provider for custom loading (e.g. caching or HTTP authorization)</param>
/// <param name="deferAgent">Defer Agent takes care of interrupting the
/// loading procedure in order to keep the frame rate responsive.</param>
/// <param name="materialGenerator">Used to convert glTF materials to <see cref="Material"/> instances</param>
/// <param name="logger">Used for message reporting</param>
/// <returns>Async Task that loads the glTF's contents</returns>
public virtual async Task <bool> Load(
string url,
IDownloadProvider downloadProvider = null,
IDeferAgent deferAgent = null,
IMaterialGenerator materialGenerator = null,
ICodeLogger logger = null
)
{
importer = new GltfImport(downloadProvider, deferAgent, materialGenerator, logger);
return(await importer.Load(url));
}
public void Load(string url = null, IDeferAgent deferAgent = null)
{
if (url != null)
{
this.url = url;
}
if (gLTFastInstance == null && loadRoutine == null)
{
this.deferAgent = deferAgent ?? new DeferTimer();
loadRoutine = StartCoroutine(LoadRoutine());
}
}
/// <summary>
/// Provides glTF export of GameObject based scenes and hierarchies.
/// </summary>
/// <param name="exportSettings">Export settings</param>
/// <param name="gameObjectExportSettings">GameObject export settings</param>
/// <param name="materialExport">Provides material conversion</param>
/// <param name="deferAgent">Defer agent; decides when/if to preempt
/// export to preserve a stable frame rate <seealso cref="IDeferAgent"/></param>
/// <param name="logger">Interface for logging (error) messages
/// <seealso cref="ConsoleLogger"/></param>
public GameObjectExport(
ExportSettings exportSettings = null,
GameObjectExportSettings gameObjectExportSettings = null,
IMaterialExport materialExport = null,
IDeferAgent deferAgent = null,
ICodeLogger logger = null
)
{
m_Settings = gameObjectExportSettings ?? new GameObjectExportSettings();
m_Writer = new GltfWriter(exportSettings, deferAgent, logger);
m_MaterialExport = materialExport ?? MaterialExport.GetDefaultMaterialExport();
m_Logger = logger;
}
public void Load(string url = null, IDeferAgent deferAgent = null, IMaterialGenerator matGenerator = null, Func <string, string> urlOverrideFunc = null)
{
urlFunc = urlOverrideFunc;
if (url != null)
{
this.url = url;
}
if (gLTFastInstance == null && loadRoutine == null)
{
this.deferAgent = deferAgent ?? new DeferTimer();
loadRoutine = StartCoroutine(LoadRoutine());
}
if (matGenerator == null)
{
matGenerator = new DefaultMaterialGenerator();
}
materialGenerator = matGenerator;
}
async Task CustomDeferAgent()
{
// Recommended: Use a common defer agent across multiple GLTFast instances!
// For a stable frame rate:
IDeferAgent deferAgent = gameObject.AddComponent <TimeBudgetPerFrameDeferAgent>();
// Or for faster loading:
deferAgent = new UninterruptedDeferAgent();
var tasks = new List <Task>();
foreach (var url in manyUrls)
{
#if GLTFAST_4_OR_NEWER
var gltf = new GLTFast.GltfImport(null, deferAgent);
#else
var gltf = new GLTFast.GLTFast(null, deferAgent);
#endif
var task = gltf.Load(url).ContinueWith(
t => {
if (t.Result)
{
#if GLTFAST_4_OR_NEWER
gltf.InstantiateMainScene(transform);
for (int sceneId = 0; sceneId < gltf.sceneCount; sceneId++)
{
gltf.InstantiateScene(transform, sceneId);
}
#else
gltf.InstantiateGltf(transform);
#endif
}
},
TaskScheduler.FromCurrentSynchronizationContext()
);
tasks.Add(task);
}
await Task.WhenAll(tasks);
}
/// <summary>
/// Method for manual loading with custom <see cref="IDownloadProvider"/> and <see cref="IDeferAgent"/>.
/// </summary>
/// <param name="url">URL of the glTF file.</param>
/// <param name="downloadProvider">Download Provider for custom loading (e.g. caching or HTTP authorization)</param>
/// <param name="deferAgent">Defer Agent takes care of interrupting the
/// loading procedure in order to keep the frame rate responsive.</param>
public virtual async Task <bool> Load(string url, IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null, IMaterialGenerator materialGenerator = null)
{
gLTFastInstance = new GLTFast(downloadProvider, deferAgent, materialGenerator);
return(await gLTFastInstance.Load(url));
}
/// <summary>
/// Method for manual loading with custom <see cref="IDeferAgent"/>.
/// </summary>
/// <param name="url">URL of the glTF file.</param>
/// <param name="deferAgent">Defer Agent takes care of interrupting the
/// loading procedure in order to keep the frame rate responsive.</param>
public void Load(string url, IDeferAgent deferAgent = null)
{
this.url = url;
Load(deferAgent);
}
public override async Task <bool> Load(string url, IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null, IMaterialGenerator materialGenerator = null)
{
var success = await base.Load(url, downloadProvider, deferAgent, materialGenerator);
if (success)
{
var insta = new GameObjectBoundsInstantiator(transform);
// Auto-Instantiate
gLTFastInstance.InstantiateGltf(insta);
var sceneBounds = insta.CalculateBounds();
if (sceneBounds.HasValue)
{
bounds = sceneBounds.Value;
if (createBoxCollider)
{
#if UNITY_PHYSICS
var boxCollider = gameObject.AddComponent <BoxCollider>();
boxCollider.center = bounds.center;
boxCollider.size = bounds.size;
#else
Debug.LogError("GltfBoundsAsset requires the built-in Physics package to be enabled (in the Package Manager)");
#endif
}
}
}
return(success);
}
void Load(IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null)
{
gLTFastInstance = new GLTFast(this, downloadProvider, deferAgent);
gLTFastInstance.onLoadComplete += OnLoadComplete;
gLTFastInstance.Load(url);
}
/// <summary>
/// Method for manual loading with custom <see cref="IDeferAgent"/>.
/// </summary>
/// <param name="url">URL of the glTF file.</param>
/// <param name="deferAgent">Defer Agent takes care of interrupting the
/// loading procedure in order to keep the frame rate responsive.</param>
public void Load(string url, IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null)
{
this.url = url;
Load(downloadProvider, deferAgent);
}
/// <summary>
/// Method for manual loading with custom <see cref="IDownloadProvider"/> and <see cref="IDeferAgent"/>.
/// </summary>
/// <param name="url">URL of the glTF file.</param>
/// <param name="downloadProvider">Download Provider for custom loading (e.g. caching or HTTP authorization)</param>
/// <param name="deferAgent">Defer Agent takes care of interrupting the
/// loading procedure in order to keep the frame rate responsive.</param>
public virtual void Load(string url, IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null, IMaterialGenerator materialGenerator = null)
{
gLTFastInstance = new GLTFast(this, downloadProvider, deferAgent, materialGenerator);
gLTFastInstance.onLoadComplete += OnLoadComplete;
gLTFastInstance.Load(url);
}
public override async Task <bool> Load(string url, IDownloadProvider downloadProvider = null, IDeferAgent deferAgent = null, IMaterialGenerator materialGenerator = null)
{
var success = await base.Load(url, downloadProvider, deferAgent, materialGenerator);
if (success)
{
if (deferAgent != null)
{
await deferAgent.BreakPoint();
}
// Auto-Instantiate
gLTFastInstance.InstantiateGltf(transform);
}
return(success);
}
