/// Update resource precaching for the given object load request.
///
/// @param[in] pRequest Load request to update.
///
/// @return True if resource precaching still requires processing, false if not.
bool AssetLoader::TickPrecache( LoadRequest* pRequest )
{
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !( pRequest->stateFlags & LOAD_FLAG_LOADED ) );
Asset* pObject = pRequest->spObject;
if( pObject )
{
// TODO: SHouldn't this be in the linking phase?
if ( !pRequest->resolver.TryFinishPrecachingDependencies() )
{
return false;
}
pRequest->resolver.Clear();
// Perform any pre-precaching work (note that we don't precache anything for the default template object for
// a given type).
OnPrecacheReady( pObject, pRequest->pPackageLoader );
if( !pObject->GetAnyFlagSet( Asset::FLAG_BROKEN ) &&
!pObject->IsDefaultTemplate() &&
pObject->NeedsPrecacheResourceData() )
{
if( !( pRequest->stateFlags & LOAD_FLAG_PRECACHE_STARTED ) )
{
if( !pObject->BeginPrecacheResourceData() )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "AssetLoader: Failed to begin precaching object \"%s\".\n" ),
*pObject->GetPath().ToString() );
pObject->SetFlags( Asset::FLAG_PRECACHED | Asset::FLAG_BROKEN );
AtomicOrRelease( pRequest->stateFlags, LOAD_FLAG_PRECACHED | LOAD_FLAG_ERROR );
return true;
}
AtomicOrRelease( pRequest->stateFlags, LOAD_FLAG_PRECACHE_STARTED );
}
if( !pObject->TryFinishPrecacheResourceData() )
{
return false;
}
}
pObject->SetFlags( Asset::FLAG_PRECACHED );
}
AtomicOrRelease( pRequest->stateFlags, LOAD_FLAG_PRECACHED );
return true;
}
/// @copydoc PackageLoader::BeginLoadObject()
size_t LoosePackageLoader::BeginLoadObject( AssetPath path, Reflect::ObjectResolver *pResolver, bool forceReload )
{
HELIUM_TRACE( TraceLevels::Info, TXT(" LoosePackageLoader::BeginLoadObject - Loading path %s\n"), *path.ToString() );
HELIUM_TRACE(
TraceLevels::Debug,
TXT( "LoosePackageLoader::BeginLoadObject: Beginning load for path \"%s\".\n"),
*path.ToString());
HELIUM_TRACE(
TraceLevels::Debug,
TXT( "LoosePackageLoader::BeginLoadObject: Beginning load for path \"%s\". pResolver = %x\n"),
*path.ToString(),
pResolver);
// Make sure preloading has completed.
HELIUM_ASSERT( m_preloadedCounter != 0 );
if( !m_preloadedCounter )
{
return Invalid< size_t >();
}
// If this package is requested, simply provide the (already loaded) package instance.
if( path == m_packagePath )
{
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( m_spPackage );
pRequest->spObject = m_spPackage.Ptr();
SetInvalid( pRequest->index );
HELIUM_ASSERT( !pRequest->spType );
HELIUM_ASSERT( !pRequest->spTemplate );
HELIUM_ASSERT( !pRequest->spOwner );
SetInvalid( pRequest->templateLoadId );
SetInvalid( pRequest->ownerLoadId );
SetInvalid( pRequest->persistentResourceDataLoadId );
pRequest->pCachedObjectDataBuffer = NULL;
pRequest->cachedObjectDataBufferSize = 0;
SetInvalid( pRequest->asyncFileLoadId );
pRequest->pAsyncFileLoadBuffer = NULL;
pRequest->asyncFileLoadBufferSize = 0;
pRequest->pResolver = NULL;
pRequest->forceReload = forceReload;
pRequest->flags = LOAD_FLAG_PRELOADED;
size_t requestId = m_loadRequests.Add( pRequest );
return requestId;
}
size_t objectIndex = FindObjectByPath( path );
size_t objectCount = GetObjectCount();
if( objectIndex >= objectCount )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to locate \"%s\" for loading. Verify the file exists.\n" ),
*path.ToString() );
return Invalid< size_t >();
}
SerializedObjectData& rObjectData = m_objects[ objectIndex ];
// Verify that the metadata was read successfully
if( !rObjectData.bMetadataGood )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to read metadata for object \"%s\" during PackagePreload. Search log for parsing errors.\n" ),
*path.ToString() );
return Invalid< size_t >();
}
// Locate the type object.
HELIUM_ASSERT( !rObjectData.typeName.IsEmpty() );
AssetType* pType = AssetType::Find( rObjectData.typeName );
if( !pType )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to locate type \"%s\" for loading object \"%s\".\n" ),
*rObjectData.typeName,
*path.ToString() );
HELIUM_TRACE(
TraceLevels::Info,
TXT( "Current registered types:\n" ) );
for ( AssetType::ConstIterator iter = AssetType::GetTypeBegin();
iter != AssetType::GetTypeEnd(); ++iter)
{
HELIUM_TRACE(
TraceLevels::Info,
TXT( " - %s\n" ),
*iter->GetName() );
}
return Invalid< size_t >();
}
#ifndef NDEBUG
size_t loadRequestSize = m_loadRequests.GetSize();
for( size_t loadRequestIndex = 0; loadRequestIndex < loadRequestSize; ++loadRequestIndex )
{
if( !m_loadRequests.IsElementValid( loadRequestIndex ) )
{
continue;
}
LoadRequest* pRequest = m_loadRequests[ loadRequestIndex ];
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( pRequest->index != objectIndex );
if( pRequest->index == objectIndex )
{
return Invalid< size_t >();
}
}
#endif
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !pRequest->spObject );
pRequest->index = objectIndex;
pRequest->spType = pType;
HELIUM_ASSERT( !pRequest->spTemplate );
HELIUM_ASSERT( !pRequest->spOwner );
SetInvalid( pRequest->templateLoadId );
SetInvalid( pRequest->ownerLoadId );
SetInvalid( pRequest->persistentResourceDataLoadId );
pRequest->pCachedObjectDataBuffer = NULL;
pRequest->cachedObjectDataBufferSize = 0;
SetInvalid( pRequest->asyncFileLoadId );
pRequest->pAsyncFileLoadBuffer = NULL;
pRequest->asyncFileLoadBufferSize = 0;
pRequest->pResolver = pResolver;
pRequest->forceReload = forceReload;
pRequest->flags = 0;
// If a fully-loaded object already exists with the same name, do not attempt to re-load the object (just mark
// the request as complete).
if ( !forceReload )
{
pRequest->spObject = Asset::FindObject( path );
}
Asset* pObject = pRequest->spObject;
if( pObject && pObject->IsFullyLoaded() )
{
pRequest->flags = LOAD_FLAG_PRELOADED;
}
else
{
HELIUM_ASSERT( !pObject || !pObject->GetAnyFlagSet( Asset::FLAG_LOADED | Asset::FLAG_LINKED ) );
// Begin loading the template and owner objects. Note that there isn't much reason to check for failure
// until we tick this request, as we need to make sure any other load requests for the template/owner that
// did succeed are properly synced anyway.
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
if( rObjectData.templatePath.IsEmpty() )
{
// Make sure the template is fully loaded.
Asset* pTemplate = pType->GetTemplate();
rObjectData.templatePath = pTemplate->GetPath();
if( pTemplate->IsFullyLoaded() )
{
pRequest->spTemplate = pTemplate;
}
else
{
pRequest->templateLoadId = pAssetLoader->BeginLoadObject( rObjectData.templatePath );
}
}
else
{
pRequest->templateLoadId = pAssetLoader->BeginLoadObject( rObjectData.templatePath );
}
AssetPath ownerPath = path.GetParent();
if( ownerPath == m_packagePath )
{
// Easy check: if the owner is this package (which is likely), we don't need to load it.
pRequest->spOwner = m_spPackage.Ptr();
}
else if( !ownerPath.IsEmpty() )
{
pRequest->ownerLoadId = pAssetLoader->BeginLoadObject( ownerPath );
}
}
size_t requestId = m_loadRequests.Add( pRequest );
return requestId;
}
/// @copydoc PackageLoader::BeginLoadObject()
size_t CachePackageLoader::BeginLoadObject( AssetPath path, Reflect::ObjectResolver *pResolver, bool forceReload )
{
HELIUM_ASSERT( m_pCache );
HELIUM_ASSERT( !forceReload ); // Not supported
// Don't load packages from the cache, but instead create them dynamically.
if( path.IsPackage() )
{
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::BeginLoadObject(): \"%s\" is a package, resolving immediately.\n",
*path.ToString() );
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
pRequest->pEntry = NULL;
pRequest->pResolver = pResolver;
ResolvePackage( pRequest->spObject, path );
HELIUM_ASSERT( pRequest->spObject );
SetInvalid( pRequest->asyncLoadId );
pRequest->pAsyncLoadBuffer = NULL;
pRequest->pPropertyDataBegin = NULL;
pRequest->pPropertyDataEnd = NULL;
pRequest->pPersistentResourceDataBegin = NULL;
pRequest->pPersistentResourceDataEnd = NULL;
SetInvalid( pRequest->ownerLoadIndex );
HELIUM_ASSERT( !pRequest->spOwner );
pRequest->forceReload = forceReload;
pRequest->flags = LOAD_FLAG_PRELOADED;
size_t requestId = m_loadRequests.Add( pRequest );
return requestId;
}
const Cache::Entry* pEntry = m_pCache->FindEntry( path, 0 );
if( !pEntry )
{
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::BeginLoadObject(): \"%s\" is not cached in this package. No load request added.\n",
*path.ToString() );
return Invalid< size_t >();
}
#ifndef NDEBUG
size_t loadRequestSize = m_loadRequests.GetSize();
for( size_t loadRequestIndex = 0; loadRequestIndex < loadRequestSize; ++loadRequestIndex )
{
if( !m_loadRequests.IsElementValid( loadRequestIndex ) )
{
continue;
}
LoadRequest* pRequest = m_loadRequests[ loadRequestIndex ];
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( pRequest->pEntry != pEntry );
if( pRequest->pEntry == pEntry )
{
HELIUM_TRACE(
TraceLevels::Error,
"CachePackageLoader::BeginLoadObject(): Duplicate load request of \"%s\". No load request added.\n",
*path.ToString() );
return Invalid< size_t >();
}
}
#endif
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
pRequest->pEntry = pEntry;
pRequest->pResolver = pResolver;
HELIUM_ASSERT( !pRequest->spObject );
SetInvalid( pRequest->asyncLoadId );
pRequest->pAsyncLoadBuffer = NULL;
pRequest->pPropertyDataBegin = NULL;
pRequest->pPropertyDataEnd = NULL;
pRequest->pPersistentResourceDataBegin = NULL;
pRequest->pPersistentResourceDataEnd = NULL;
SetInvalid( pRequest->ownerLoadIndex );
HELIUM_ASSERT( !pRequest->spOwner );
pRequest->forceReload = forceReload;
pRequest->flags = 0;
// If a fully-loaded object already exists with the same name, do not attempt to re-load the object (just mark
// the request as complete).
pRequest->spObject = Asset::FindObject( pEntry->path );
Asset* pObject = pRequest->spObject;
if( pObject && pObject->IsFullyLoaded() )
{
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::BeginLoadObject(): \"%s\" is already fully loaded. Bypassing load process.\n",
*path.ToString() );
pRequest->flags = LOAD_FLAG_PRELOADED;
}
else
{
HELIUM_ASSERT( !pObject || !pObject->GetAnyFlagSet( Asset::FLAG_LOADED | Asset::FLAG_LINKED ) );
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::BeginLoadObject(): Issuing async load of property data for \"%s\".\n",
*path.ToString() );
size_t entrySize = pEntry->size;
pRequest->pAsyncLoadBuffer = static_cast< uint8_t* >( DefaultAllocator().Allocate( entrySize ) );
HELIUM_ASSERT( pRequest->pAsyncLoadBuffer );
AsyncLoader* pAsyncLoader = AsyncLoader::GetInstance();
HELIUM_ASSERT( pAsyncLoader );
pRequest->asyncLoadId = pAsyncLoader->QueueRequest(
pRequest->pAsyncLoadBuffer,
m_pCache->GetCacheFileName(),
pEntry->offset,
entrySize );
HELIUM_ASSERT( IsValid( pRequest->asyncLoadId ) );
}
size_t requestId = m_loadRequests.Add( pRequest );
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::BeginLoadObject(): Load request for \"%s\" added (ID: %" PRIuSZ ").\n",
*path.ToString(),
requestId );
return requestId;
}
