//[-------------------------------------------------------]
//[ Public methods ]
//[-------------------------------------------------------]
// TODO(co) Work-in-progress
ShaderPieceResourceId ShaderPieceResourceManager::loadShaderPieceResourceByAssetId(AssetId assetId, IResourceListener* resourceListener, bool reload)
{
const Asset* asset = mRendererRuntime.getAssetManager().getAssetByAssetId(assetId);
if (nullptr != asset)
{
// Get or create the instance
ShaderPieceResource* shaderPieceResource = nullptr;
{
const uint32_t numberOfElements = mShaderPieceResources.getNumberOfElements();
for (uint32_t i = 0; i < numberOfElements; ++i)
{
ShaderPieceResource& currentShaderPieceResource = mShaderPieceResources.getElementByIndex(i);
if (currentShaderPieceResource.getAssetId() == assetId)
{
shaderPieceResource = ¤tShaderPieceResource;
// Get us out of the loop
i = numberOfElements;
}
}
}
// Create the resource instance
bool load = reload;
if (nullptr == shaderPieceResource)
{
shaderPieceResource = &mShaderPieceResources.addElement();
shaderPieceResource->setResourceManager(this);
shaderPieceResource->setAssetId(assetId);
load = true;
}
if (nullptr != shaderPieceResource && nullptr != resourceListener)
{
shaderPieceResource->connectResourceListener(*resourceListener);
}
// Load the resource, if required
if (load)
{
// Prepare the resource loader
ShaderPieceResourceLoader* shaderPieceResourceLoader = static_cast<ShaderPieceResourceLoader*>(acquireResourceLoaderInstance(ShaderPieceResourceLoader::TYPE_ID));
shaderPieceResourceLoader->initialize(*asset, *shaderPieceResource);
// Commit resource streamer asset load request
ResourceStreamer::LoadRequest resourceStreamerLoadRequest;
resourceStreamerLoadRequest.resource = shaderPieceResource;
resourceStreamerLoadRequest.resourceLoader = shaderPieceResourceLoader;
mRendererRuntime.getResourceStreamer().commitLoadRequest(resourceStreamerLoadRequest);
}
// Done
return shaderPieceResource->getId();
}
// Error!
return getUninitialized<ShaderPieceResourceId>();
}
// TODO(co) Work-in-progress
TextureResourceId TextureResourceManager::loadTextureResourceByAssetId(AssetId assetId, IResourceListener* resourceListener, bool reload)
{
TextureResourceId textureResourceId = getUninitialized<TextureResourceId>();
// Check whether or not the texture resource already exists
TextureResource* textureResource = getTextureResourceByAssetId(assetId);
// Create the resource instance
const Asset* asset = mRendererRuntime.getAssetManager().getAssetByAssetId(assetId);
bool load = (reload && nullptr != asset);
if (nullptr == textureResource && nullptr != asset)
{
textureResource = &mTextureResources.addElement();
textureResource->setResourceManager(this);
textureResource->setAssetId(assetId);
load = true;
}
if (nullptr != textureResource)
{
if (nullptr != resourceListener)
{
textureResource->connectResourceListener(*resourceListener);
}
textureResourceId = textureResource->getId();
}
// Load the resource, if required
if (load)
{
// Prepare the resource loader
// -> The totally primitive texture resource loader type detection is sufficient for now
const char* filenameExtension = strrchr(&asset->assetFilename[0], '.');
if (nullptr != filenameExtension)
{
ITextureResourceLoader* textureResourceLoader = static_cast<ITextureResourceLoader*>(acquireResourceLoaderInstance(StringId(filenameExtension + 1)));
if (nullptr != textureResourceLoader)
{
textureResourceLoader->initialize(*asset, *textureResource);
// Commit resource streamer asset load request
ResourceStreamer::LoadRequest resourceStreamerLoadRequest;
resourceStreamerLoadRequest.resource = textureResource;
resourceStreamerLoadRequest.resourceLoader = textureResourceLoader;
mRendererRuntime.getResourceStreamer().commitLoadRequest(resourceStreamerLoadRequest);
}
}
else
{
// TODO(co) Error handling
}
}
// Done
return textureResourceId;
}
