private T[] GetAssets <T>()
where T : Object
{
return((from pair in m_assets[(int)RestoredAssetsRoot.FindAssetType <T>()]
where pair.Value.Asset is T
select pair.Value.Asset as T).ToArray());
}
private RestoredAssetsRoot GetOrCreateRoot(RestoredAssetsRoot.ContainingType assetType)
{
var root = Utils.FindAssetsOfType <RestoredAssetsRoot>(m_dataDirectory).FirstOrDefault(r => r != null &&
r.Type == assetType);
if (root == null)
{
root = RestoredAssetsRoot.Create(m_filename, assetType);
// Re-import of previous version without root if there are assets
// of the given type. Add root and set it as main object.
var existingAssets = GetAssets(assetType);
if (existingAssets.Length == 0)
{
AssetDatabase.CreateAsset(root, GetAssetPath(root));
}
else
{
AssetDatabase.AddObjectToAsset(root,
System.Array.Find(existingAssets,
asset => AssetDatabase.IsMainAsset(asset)) ??
existingAssets[0]);
m_statistics.RootsAddedToExistingAssets = true;
}
}
return(m_assetRoots[(int)assetType] = root);
}
public bool ContainsAsset <T>(T asset)
where T : ScriptableObject
{
if (asset == null)
{
return(false);
}
return(m_assets[RestoredAssetsRoot.FindAssetTypeIndex <T>()].ContainsKey(asset.GetHashCode()));
}
private T GetOrCreateAsset <T>(T current,
string name,
System.Action <T> onFirstRef,
System.Func <T> factory)
where T : Object
{
if (factory == null)
{
throw new System.ArgumentNullException("factory");
}
var isNewInstance = current == null;
if (current == null)
{
if (current == null)
{
current = factory();
}
else
{
Debug.Assert(RestoredAssetsRoot.FindAssetType <T>() == RestoredAssetsRoot.ContainingType.Unknown);
}
m_assets[RestoredAssetsRoot.FindAssetTypeIndex <T>()].Add(current.GetHashCode(),
new AssetDbData()
{
Asset = current,
RefCount = 0
});
}
var data = m_assets[RestoredAssetsRoot.FindAssetTypeIndex <T>()][current.GetHashCode()];
if (data.RefCount == 0)
{
onFirstRef(current);
current.name = name;
if (isNewInstance)
{
AssetDatabase.AddObjectToAsset(current, GetRoot(RestoredAssetsRoot.FindAssetType <T>()));
++m_statistics.NumAddedAssets;
}
}
data.RefCount += 1;
return(current);
}
public int GetRefCount(Object obj)
{
if (obj == null)
{
return(-1);
}
var dict = m_assets[(int)RestoredAssetsRoot.FindAssetType(obj.GetType())];
if (dict == null)
{
return(-1);
}
AssetDbData data = null;
if (dict.TryGetValue(obj.GetHashCode(), out data))
{
return(data.RefCount);
}
return(-1);
}
public static Object[] GetAssets(string dataDirectory, RestoredAssetsRoot.ContainingType assetType)
{
var root = Utils.FindAssetsOfType <RestoredAssetsRoot>(dataDirectory).FirstOrDefault(assetRoot => assetRoot.Type == assetType);
var assets = new List <Object>();
if (root != null)
{
assets.Add(root);
}
if (assetType == RestoredAssetsRoot.ContainingType.Unknown)
{
assets.AddRange(from type in s_unknownTypes
from asset in Utils.FindAssetsOfType(dataDirectory, type)
select asset);
}
else
{
assets.AddRange(from asset in Utils.FindAssetsOfType(dataDirectory, RestoredAssetsRoot.GetType(assetType))
where asset.GetType() == RestoredAssetsRoot.GetType(assetType)
select asset);
}
return(assets.ToArray());
}
