//////////////////////////////////////////////////////////////////////////
// processLoadedResource
void CsCore::processLoadedResource()
{
BcScopedLock< BcMutex > Lock( ContainerLock_ );
static BcBool DumpResources = BcFalse;
if( DumpResources )
{
BcPrintf( "==========================================\n" );
BcPrintf( "CsCore: Dump Resource:\n" );
BcPrintf( "==========================================\n" );
}
TResourceListIterator It( LoadedResources_.begin() );
while( It != LoadedResources_.end() )
{
CsResource* pResource = (*It);
BcUnusedVar( pResource );
// NOTE: Placeholder for doing stuff. Probably don't need to other
// than for debug purposes.
if( DumpResources )
{
BcPrintf( "%s (%s)\n", (*pResource->getName()).c_str(), (*pResource->getType()).c_str() );
}
++It;
}
if( DumpResources )
{
BcPrintf( "==========================================\n" );
DumpResources = BcFalse;
}
}
//////////////////////////////////////////////////////////////////////////
// processUnloadingResources
void CsCore::processUnloadingResources()
{
std::lock_guard< std::recursive_mutex > Lock( ContainerLock_ );
while( UnloadingResources_.size() > 0 )
{
TResourceList ResourceList = UnloadingResources_;
TResourceListIterator It( ResourceList.begin() );
while( It != ResourceList.end() )
{
CsResource* pResource = (*It);
// Destroy resource.
pResource->destroy();
// Free resource.
pResource->getClass()->destruct( pResource );
BcMemFree( pResource );
// Next.
++It;
}
UnloadingResources_.clear();
}
}
//virtual
BcBool CsSerialiserPackageObjectCodec::shouldSerialiseContents(
void* InData,
const ReClass* InType )
{
BcBool RetVal = BcFalse;
if( Package_ != nullptr )
{
const ReClass* InClass = static_cast< const ReClass* >( InType );
if( InClass->hasBaseClass( ReObject::StaticGetClass() ) )
{
CsResource* Resource = reinterpret_cast< CsResource* >( InData );
ReObject* ResourceRootOwner = Resource->getRootOwner();
if( Package_ == ResourceRootOwner )
{
RetVal = BcTrue;
}
}
else
{
RetVal = BcTrue;
}
}
else
{
RetVal = BcTrue;
}
return RetVal;
}
//////////////////////////////////////////////////////////////////////////
// allocResource
CsResource* CsCore::allocResource( const BcName& Name, const ReClass* Class, BcU32 Index, CsPackage* pPackage )
{
std::lock_guard< std::recursive_mutex > Lock( ContainerLock_ );
CsResource* pResource = NULL;
void* pResourceBuffer = BcMemAlign( Class->getSize() );
pResource = Class->construct< CsResource >( pResourceBuffer );
pResource->preInitialise( Name, Index, pPackage );
return pResource;
}
//////////////////////////////////////////////////////////////////////////
// getResource
CsResource* CsPackage::getResource( BcU32 ResourceIdx )
{
CsResource* pResource = NULL;
if( ResourceIdx < Resources_.size() )
{
pResource = Resources_[ ResourceIdx ];
BcAssert( pResource->getIndex() == ResourceIdx );
}
return pResource;
}
//////////////////////////////////////////////////////////////////////////
// processUnloadingResources
void CsCore::processUnloadingResources()
{
BcScopedLock< BcMutex > Lock( ContainerLock_ );
TResourceListIterator It( UnloadingResources_.begin() );
while( It != UnloadingResources_.end() )
{
CsResource* pResource = (*It);
// Destroy resource.
pResource->destroy();
// Free resource.
delete pResource;
// Remove from list.
It = UnloadingResources_.erase( It );
}
}
//virtual
std::string CsSerialiserPackageObjectCodec::serialiseAsStringRef(
void* InData,
const ReClass* InType )
{
std::string RetVal;
if( Package_ != nullptr )
{
const ReClass* InClass = static_cast< const ReClass* >( InType );
// Check if it's a resource.
if( InClass->hasBaseClass( ReObject::StaticGetClass() ) )
{
CsResource* Resource = reinterpret_cast< CsResource* >( InData );
ReObject* ResourceRootOwner = Resource->getRootOwner();
if( ResourceRootOwner != nullptr )
{
BcChar OutChars[ 128 ];
BcSPrintf( OutChars, "$(%s:%s.%s)",
(*Resource->getClass()->getName()).c_str(),
(*ResourceRootOwner->getName()).c_str(),
(*Resource->getName()).c_str() );
RetVal = OutChars;
}
}
}
if( RetVal.empty() )
{
// Default formatting.
BcChar OutChars[ 128 ];
BcSPrintf( OutChars, "$(%s:%s.%llu)",
(*InType->getName()).c_str(),
( "this" ),
( (unsigned long long)InData ) );
}
return RetVal;
}
//////////////////////////////////////////////////////////////////////////
// close
//virtual
void CsCore::close()
{
// Verify we have no more resources to be created or loading.
BcVerifyMsg( CreateResources_.size() == 0, "CsCore: Resources to be created, but system is closing!" );
BcVerifyMsg( LoadingResources_.size() == 0, "CsCore: Resources currently loading, but system is closing!" );
while( PackageList_.size() > 0 )
{
freeUnreferencedPackages();
// Finish processing unloading resources.
if( UnloadingResources_.size() > 0 )
{
processUnloadingResources();
}
}
if( LoadedResources_.size() > 0 )
{
BcPrintf( "==========================================\n" );
BcPrintf( "CsCore: Dump Resource On Exit:\n" );
BcPrintf( "==========================================\n" );
TResourceListIterator It( LoadedResources_.begin() );
while( It != LoadedResources_.end() )
{
CsResource* pResource = (*It);
BcPrintf( "%s.%s:%s \n", (*pResource->getPackageName()).c_str(), (*pResource->getName()).c_str(), (*pResource->getTypeName()).c_str() );
++It;
}
BcPrintf( "==========================================\n" );
}
// Verify we don't have any left floating loaded or unloading.
BcVerifyMsg( LoadedResources_.size() == 0, "CsCore: Resources still loaded, but system is closing! Has the scene cleaned up properly?" );
BcVerifyMsg( UnloadingResources_.size() == 0, "CsCore: Resources still unloading, but system is closing!" );
}
