/// @copydoc AssetLoader::CacheObject()
bool LooseAssetLoader::CacheObject( Asset* pAsset, bool bEvictPlatformPreprocessedResourceData )
{
HELIUM_ASSERT( pAsset );
HELIUM_TRACE(
TraceLevels::Info,
TXT( "LooseAssetLoader::CacheObject(): Caching asset %s.\n" ), *pAsset->GetPath().ToString() );
// Don't cache broken objects or packages.
if( pAsset->GetAnyFlagSet( Asset::FLAG_BROKEN ) || pAsset->IsPackage() )
{
return false;
}
// Make sure we have an object preprocessor instance with which to cache the object.
AssetPreprocessor* pAssetPreprocessor = AssetPreprocessor::GetStaticInstance();
if( !pAssetPreprocessor )
{
HELIUM_TRACE(
TraceLevels::Warning,
TXT( "LooseAssetLoader::CacheObject(): Missing AssetPreprocessor to use for caching.\n" ) );
return false;
}
// User configuration objects should not be cached.
AssetPath objectPath = pAsset->GetPath();
Config& rConfig = Config::GetStaticInstance();
// Only cache the files we care about
if ( rConfig.IsAssetPathInUserConfigPackage(objectPath) )
{
return false;
}
int64_t objectTimestamp = pAsset->GetAssetFileTimeStamp();
if( !pAsset->IsDefaultTemplate() )
{
Resource* pResource = Reflect::SafeCast< Resource >( pAsset );
if( pResource )
{
AssetPath baseResourcePath = pResource->GetPath();
HELIUM_ASSERT( !baseResourcePath.IsPackage() );
for( ; ; )
{
AssetPath parentPath = baseResourcePath.GetParent();
if( parentPath.IsEmpty() || parentPath.IsPackage() )
{
break;
}
baseResourcePath = parentPath;
}
FilePath sourceFilePath;
if ( !FileLocations::GetDataDirectory( sourceFilePath ) )
{
HELIUM_TRACE(
TraceLevels::Warning,
TXT( "LooseAssetLoader::CacheObject(): Could not obtain data directory.\n" ) );
return false;
}
sourceFilePath += baseResourcePath.ToFilePathString().GetData();
Status stat;
stat.Read( sourceFilePath.Get().c_str() );
int64_t sourceFileTimestamp = stat.m_ModifiedTime;
if( sourceFileTimestamp > objectTimestamp )
{
objectTimestamp = sourceFileTimestamp;
}
}
}
// Cache the object.
bool bSuccess = pAssetPreprocessor->CacheObject(
pAsset,
objectTimestamp,
bEvictPlatformPreprocessedResourceData );
if( !bSuccess )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LooseAssetLoader: Failed to cache object \"%s\".\n" ),
*objectPath.ToString() );
}
return bSuccess;
}
/// Update processing of persistent resource data loading for a given load request.
///
/// @param[in] pRequest Load request to process.
///
/// @return True if persistent resource data loading for the given load request has completed, false if not.
bool LoosePackageLoader::TickPersistentResourcePreload( LoadRequest* pRequest )
{
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !( pRequest->flags & LOAD_FLAG_PERSISTENT_RESOURCE_PRELOADED ) );
Resource* pResource = Reflect::AssertCast< Resource >( pRequest->spObject.Get() );
HELIUM_ASSERT( pResource );
// Wait for the cached data load to complete.
AsyncLoader& rAsyncLoader = AsyncLoader::GetStaticInstance();
size_t bytesRead = 0;
HELIUM_ASSERT( IsValid( pRequest->persistentResourceDataLoadId ) );
if( !rAsyncLoader.TrySyncRequest( pRequest->persistentResourceDataLoadId, bytesRead ) )
{
return false;
}
SetInvalid( pRequest->persistentResourceDataLoadId );
if( bytesRead != pRequest->cachedObjectDataBufferSize )
{
HELIUM_TRACE(
TraceLevels::Warning,
( TXT( "LoosePackageLoader: Requested load of %" ) PRIu32 TXT( " bytes from cached object data for " )
TXT( "\"%s\", but only %" ) PRIuSZ TXT( " bytes were read.\n" ) ),
pRequest->cachedObjectDataBufferSize,
*pResource->GetPath().ToString(),
bytesRead );
}
// Make sure we read enough bytes to cover the object property data size.
if( bytesRead < sizeof( uint32_t ) )
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader: Not enough bytes read of cached object data \"%s\" from which to parse the " )
TXT( "property stream size.\n" ) ),
*pResource->GetPath().ToString() );
pRequest->flags |= LOAD_FLAG_ERROR;
}
else
{
// Skip over the object property data.
uint8_t* pCachedObjectData = pRequest->pCachedObjectDataBuffer;
HELIUM_ASSERT( pCachedObjectData );
uint32_t propertyDataSize = *reinterpret_cast< uint32_t* >( pCachedObjectData );
size_t byteSkipCount = sizeof( propertyDataSize ) + propertyDataSize;
if( byteSkipCount > bytesRead )
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader: Cached persistent resource data for \"%s\" extends past the end of the " )
TXT( "cached data stream.\n" ) ),
*pResource->GetPath().ToString() );
pRequest->flags |= LOAD_FLAG_ERROR;
}
else
{
pCachedObjectData += byteSkipCount;
size_t bytesRemaining = bytesRead - byteSkipCount;
// Make sure we have enough bytes at the end for the resource sub-data count.
if( bytesRemaining < sizeof( uint32_t ) )
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader: Not enough space is reserved in the cached persistent resource " )
TXT( "data stream for \"%s\" for the resource sub-data count.\n" ) ),
*pResource->GetPath().ToString() );
pRequest->flags |= LOAD_FLAG_ERROR;
}
else
{
bytesRemaining -= sizeof( uint32_t );
//// Deserialize the persistent resource data.
//// Having to do this copy is unfortunate.. maybe we can revisit this later
//std::stringstream ss_in;
//ss_in.write(reinterpret_cast<char *>(pCachedObjectData), bytesRemaining);
//Reflect::ArchiveBinary archive(new Reflect::CharStream(&ss_in, false, Helium::ByteOrders::LittleEndian, Helium::Reflect::CharacterEncodings::UTF_16), false);
//Reflect::ObjectPtr persistent_data;
//archive.ReadSingleObject(persistent_data);
Reflect::ObjectPtr persistent_data;
persistent_data = Cache::ReadCacheObjectFromBuffer(pCachedObjectData, /*sizeof( uint32_t )*/ 0, bytesRemaining, pRequest->pResolver);
if (!pResource->LoadPersistentResourceObject(persistent_data))
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader: Failed to load persistent resource object for \"%s\".\n" ) ),
*pResource->GetPath().ToString() );
pRequest->flags |= LOAD_FLAG_ERROR;
}
}
}
}
DefaultAllocator().Free( pRequest->pCachedObjectDataBuffer );
pRequest->pCachedObjectDataBuffer = NULL;
pRequest->cachedObjectDataBufferSize = 0;
pResource->SetFlags( Asset::FLAG_PRELOADED );
pRequest->flags |= LOAD_FLAG_PERSISTENT_RESOURCE_PRELOADED;
return true;
}
/// @copydoc GameObjectLoader::CacheObject()
bool EditorObjectLoader::CacheObject( GameObject* pObject, bool bEvictPlatformPreprocessedResourceData )
{
HELIUM_ASSERT( pObject );
// Don't cache broken objects or packages.
if( pObject->GetAnyFlagSet( GameObject::FLAG_BROKEN ) || pObject->IsPackage() )
{
return false;
}
// Make sure we have an object preprocessor instance with which to cache the object.
ObjectPreprocessor* pObjectPreprocessor = ObjectPreprocessor::GetStaticInstance();
if( !pObjectPreprocessor )
{
HELIUM_TRACE(
TRACE_WARNING,
TXT( "EditorObjectLoader::CacheObject(): Missing ObjectPreprocessor to use for caching.\n" ) );
return false;
}
// Configuration objects should not be cached.
GameObjectPath objectPath = pObject->GetPath();
Config& rConfig = Config::GetStaticInstance();
GameObjectPath configPackagePath = rConfig.GetConfigContainerPackagePath();
HELIUM_ASSERT( !configPackagePath.IsEmpty() );
for( GameObjectPath testPath = objectPath; !testPath.IsEmpty(); testPath = testPath.GetParent() )
{
if( testPath == configPackagePath )
{
return false;
}
}
// Get the timestamp for the object based on the timestamp of its source package file and, if it's a resource,
// the timestamp of the source resource file.
GameObject* pPackageObject;
for( pPackageObject = pObject;
pPackageObject && !pPackageObject->IsPackage();
pPackageObject = pPackageObject->GetOwner() )
{
}
HELIUM_ASSERT( pPackageObject );
PackageLoader* pPackageLoader = Reflect::AssertCast< Package >( pPackageObject )->GetLoader();
HELIUM_ASSERT( pPackageLoader );
HELIUM_ASSERT( pPackageLoader->IsSourcePackageFile() );
int64_t objectTimestamp = pPackageLoader->GetFileTimestamp();
if( !pObject->IsDefaultTemplate() )
{
Resource* pResource = Reflect::SafeCast< Resource >( pObject );
if( pResource )
{
GameObjectPath baseResourcePath = pResource->GetPath();
HELIUM_ASSERT( !baseResourcePath.IsPackage() );
for( ; ; )
{
GameObjectPath parentPath = baseResourcePath.GetParent();
if( parentPath.IsEmpty() || parentPath.IsPackage() )
{
break;
}
baseResourcePath = parentPath;
}
Path sourceFilePath;
if ( !File::GetDataDirectory( sourceFilePath ) )
{
HELIUM_TRACE(
TRACE_WARNING,
TXT( "EditorObjectLoader::CacheObject(): Could not obtain data directory.\n" ) );
return false;
}
sourceFilePath += baseResourcePath.ToFilePathString().GetData();
int64_t sourceFileTimestamp = sourceFilePath.ModifiedTime();
if( sourceFileTimestamp > objectTimestamp )
{
objectTimestamp = sourceFileTimestamp;
}
}
}
// Cache the object.
bool bSuccess = pObjectPreprocessor->CacheObject(
pObject,
objectTimestamp,
bEvictPlatformPreprocessedResourceData );
if( !bSuccess )
{
HELIUM_TRACE(
TRACE_ERROR,
TXT( "EditorObjectLoader: Failed to cache object \"%s\".\n" ),
*objectPath.ToString() );
}
return bSuccess;
}
