Vector<AssetPtr> AssetRefListListener::Assets() const
{
    Vector<AssetPtr> assets;
    for (uint i = 0; i < current_.Size(); ++i)
    {
        const AssetReference &ref = current_[i];
        if (!ref.ref.Empty())
            assets.Push(assetAPI_->FindAsset(ref.ref));
        else
            assets.Push(AssetPtr());
    }
    return assets;
}
Exemple #2
0
	AssetPtr AssetManager::FindAsset(const boost::filesystem::path& file)
	{
		AssetMap::iterator it = m_assets.find(file.string());
		if(it != m_assets.end())
		{
			if(it->second->Ready())
			{
				return it->second;
			}
		}

		return AssetPtr();
	}
Exemple #3
0
	AssetPtr AssetManager::LoadAsset(const boost::filesystem::path& file)
	{
		AssetPtr pAsset = FindAsset(file);
		if(pAsset)
		{
			pAsset->IncRef();
			return pAsset;
		}

		AssetLoader loader = FindLoader(file);
		if(loader)
		{
			return AssetPtr();
		}
		pAsset = loader(file);

		m_assets[file.string()] = pAsset;
		return pAsset;
	}
Exemple #4
0
	AssetPtr AssetManager::LoadSound(const boost::filesystem::path& file, bool sound3d)
	{
		SoundPtr pSound;
		
		if(sound3d)
		{
			pSound = m_pSound->Create3DSound(file.string().c_str());
		}
		else
		{
			pSound = m_pSound->CreateSound(file.string().c_str());
		}
		if(pSound == nullptr)
		{
			return AssetPtr();
		}

		AssetPtr pAsset = alloc_object<SoundAsset, SoundPtr>(pSound);

		return pAsset;
	}
Exemple #5
0
AssetPtr IAsset::Clone(QString newAssetName) const
{
    assert(assetAPI);
    if (!IsLoaded())
        return AssetPtr();

    AssetPtr existing = assetAPI->GetAsset(newAssetName);
    if (existing)
    {
        LogError("Cannot Clone() asset \"" + Name() + "\" to a new asset \"" + newAssetName + "\": An asset with that name already exists!");
        return AssetPtr();
    }

    std::vector<u8> data;
    bool success = SerializeTo(data);
    if (!success)
    {
        LogError("Cannot Clone() asset \"" + Name() + "\" to a new asset \"" + newAssetName + "\": Serializing the asset failed!");
        return AssetPtr();
    }
    if (data.size() == 0)
    {
        LogError("Cannot Clone() asset \"" + Name() + "\" to a new asset \"" + newAssetName + "\": Asset serialization succeeded with zero size!");
        return AssetPtr();
    }

    AssetPtr newAsset = assetAPI->CreateNewAsset(this->Type(), newAssetName);
    if (!newAsset)
    {
        LogError("Cannot Clone() asset \"" + Name() + "\" to a new asset \"" + newAssetName + "\": AssetAPI::CreateNewAsset failed!");
        return AssetPtr();
    }

    // Do not allow asynchronous loading due the caller of this 
    // expects the asset to be usable when this function returns.
    success = newAsset->LoadFromFileInMemory(&data[0], data.size(), false);
    if (!success)
    {
        LogError("Cannot Clone() asset \"" + Name() + "\" to a new asset \"" + newAssetName + "\": Deserializing the new asset from bytes failed!");
        assetAPI->ForgetAsset(newAsset, false);
        return AssetPtr();
    }

    return newAsset;
}
void AssetRefListener::HandleAssetRefChange(AssetAPI *assetApi, String assetRef, const String& assetType)
{
    // Disconnect from any previous transfer we might be listening to
    if (!currentTransfer.Expired())
    {
        IAssetTransfer* current = currentTransfer.Get();
        current->Succeeded.Disconnect(this, &AssetRefListener::OnTransferSucceeded);
        current->Failed.Disconnect(this, &AssetRefListener::OnTransferFailed);
        currentTransfer.Reset();
    }
    
    assert(assetApi);

    // Store AssetAPI ptr for later signal hooking.
    if (!myAssetAPI)
        myAssetAPI = assetApi;

    // If the ref is empty, don't go any further as it will just trigger the LogWarning below.
    assetRef = assetRef.Trimmed();
    if (assetRef.Empty())
    {
        asset = AssetPtr();
        return;
    }
    currentWaitingRef = "";

    // Resolve the protocol for generated:// assets. These assets are never meant to be
    // requested from AssetAPI, they cannot be fetched from anywhere. They can only be either
    // loaded or we must wait for something to load/create them.
    String protocolPart = "";
    assetApi->ParseAssetRef(assetRef, &protocolPart);
    if (protocolPart.ToLower() == "generated")
    {
        AssetPtr loadedAsset = assetApi->FindAsset(assetRef);
        if (loadedAsset.Get() && loadedAsset->IsLoaded())
        {
            // Asset is loaded, emit Loaded with 1 msec delay to preserve the logic
            // that HandleAssetRefChange won't emit anything itself as before.
            // Otherwise existing connection can break/be too late after calling this function.
            asset = loadedAsset;
            assetApi->GetFramework()->Frame()->DelayedExecute(0.0f).Connect(this, &AssetRefListener::EmitLoaded);
            return;
        }
        else
        {
            // Wait for it to be created.
            currentWaitingRef = assetRef;
            myAssetAPI->AssetCreated.Connect(this, &AssetRefListener::OnAssetCreated);
        }
    }
    else
    {
        // This is not a generated asset, request normally from asset api.
        AssetTransferPtr transfer = assetApi->RequestAsset(assetRef, assetType);
        if (!transfer)
        {
            LogWarning("AssetRefListener::HandleAssetRefChange: Asset request for asset \"" + assetRef + "\" failed.");
            return;
        }
        currentWaitingRef = assetRef;

        transfer->Succeeded.Connect(this, &AssetRefListener::OnTransferSucceeded);
        transfer->Failed.Connect(this, &AssetRefListener::OnTransferFailed);

        currentTransfer = transfer;
    }
    
    // Disconnect from the old asset's load signal
    if (asset)
        asset->Loaded.Disconnect(this, &AssetRefListener::OnAssetLoaded);
    asset = AssetPtr();
}
AssetPtr AssetRefListListener::Asset(uint index) const
{
    if (index < current_.Size() && !current_[index].ref.Empty())
        return assetAPI_->FindAsset(current_[index].ref);
    return AssetPtr();
}