protected override void ReloadGraphicsAssets()
{
foreach (var pair in loadedAssets)
{
if (pair.Value.UseContentReader && pair.Value.Asset != null)
{
LoadedAssets.Add(pair.Value.AssetFileName, pair.Value.Asset);
}
}
base.ReloadGraphicsAssets();
foreach (var pair in LoadedAssets)
{
foreach (var pair2 in loadedAssets)
{
if (pair2.Value.AssetFileName == pair.Key)
{
loadedAssets[pair2.Key].Asset = pair.Value;
}
}
}
LoadedAssets.Clear();
}
public void UnloadAsset <T>(string assetName) where T : class, IDisposable
{
if (IsAssetLoaded(assetName))
{
try
{
var assetToRemove = LoadedAssets[assetName];
for (var i = 0; i < DisposableAssets.Count; i++)
{
var typedAsset = DisposableAssets[i] as T;
if (typedAsset != null && typedAsset == assetToRemove)
{
typedAsset.Dispose();
DisposableAssets.RemoveAt(i);
break;
}
}
LoadedAssets.Remove(assetName);
}
catch (Exception e)
{
Console.WriteLine("Cound not unload asset {0}. {1}", assetName, e);
}
}
}
/// <summary>
/// loads a texture2D from xnb or from png/jpg. Xnb should not have extension while later should.
/// </summary>
/// <param name="name"></param>
/// <param name="premultiplyAlpha"></param>
/// <returns></returns>
public Texture2D LoadTexture(string name, bool premultiplyAlpha = false)
{
//if no extension assume an xnb
if (string.IsNullOrEmpty(Path.GetExtension(name)))
{
var result = Load <Texture2D>(name);
return(result);
//return Load<Texture2D>(name);
}
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is Texture2D tex)
{
return(tex);
}
}
using (var stream = Path.IsPathRooted(name) ? File.OpenRead(name) : TitleContainer.OpenStream(name))
{
var texture = Texture2D.FromStream(SolisCore.Instance.GraphicsDevice, stream);
texture.Name = name;
LoadedAssets[name] = texture;
DisposableAssets.Add(texture);
return(texture);
}
}
private void Refresh()
{
var list = new List <string>();
foreach (var entry in assetLoadingTimeUrls)
{
var asset = editor.Session.GetAssetById(entry.Key);
list.Add($"{(asset != null ? asset.Url : "<Unknown: " + entry.Key + ">")} -> {entry.Value}");
}
LoadingTimeUrls.Clear();
LoadingTimeUrls.AddRange(list);
list.Clear();
// TODO: display a fallback message when this service is not available.
var debug = editor.Controller.GetService <IEditorGameDebugViewModelService>();
if (debug != null)
{
foreach (var entry in debug.ContentManagerStats.LoadedAssets)
{
list.Add($"{entry.Url}: Pub:{entry.PublicReferenceCount} Priv:{entry.PrivateReferenceCount}");
}
}
LoadedAssets.Clear();
LoadedAssets.AddRange(list);
}
/// <summary>
/// loads a Texture2D either from xnb or directly from a png/jpg. Note that xnb files should not contain the .xnb file
/// extension or be preceded by "Content" in the path. png/jpg files should have the file extension and have an absolute
/// path or a path starting with "Content".
/// </summary>
public Texture2D LoadTexture(string name, bool premultiplyAlpha = false)
{
// no file extension. Assumed to be an xnb so let ContentManager load it
if (string.IsNullOrEmpty(Path.GetExtension(name)))
{
return(Load <Texture2D>(name));
}
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is Texture2D tex)
{
return(tex);
}
}
using (var stream = Path.IsPathRooted(name) ? File.OpenRead(name) : TitleContainer.OpenStream(name))
{
var texture = premultiplyAlpha ? TextureUtils.TextureFromStreamPreMultiplied(stream) : Texture2D.FromStream(Core.GraphicsDevice, stream);
texture.Name = name;
LoadedAssets[name] = texture;
DisposableAssets.Add(texture);
return(texture);
}
}
// loads audio
private void LoadAudio(string assetName)
{
SoundEffect soundEffect = Load <SoundEffect>(assetName);
LoadedAssets.Remove(assetName); // remove the sound effect with key extension (pack:dir/dir/file.xnb)
AddLoadedAsset(assetName, soundEffect); // add the sound effect without an extension (pack:dir/dir/file)
}
// adds an asset to the loaded assets dictionary with the correctally formatted key
private void AddLoadedAsset(string assetName, object asset)
{
string ext = Path.GetExtension(assetName);
string key = assetName.Remove(assetName.Length - ext.Length);
LoadedAssets.Add(key, asset);
}
public OgmoProject LoadOgmoProject(string name)
{
if (string.IsNullOrEmpty(Path.GetExtension(name)))
{
name = Path.ChangeExtension(name, "ogmo");
}
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is OgmoProject project)
{
return(project);
}
}
using (var stream = Path.IsPathRooted(name) ? File.OpenRead(name) : TitleContainer.OpenStream(name))
{
using (var reader = new StreamReader(stream))
{
JsonSerializer ser = new JsonSerializer()
{
Context = new StreamingContext(StreamingContextStates.Other, name)
};
var proj = (OgmoProject)ser.Deserialize(reader, typeof(OgmoProject));
LoadedAssets[name] = proj;
proj.ParentContentManager = this;
return(proj);
}
}
}
public virtual T Load <T>(string assetName)
{
if (string.IsNullOrEmpty(assetName))
{
throw new ArgumentNullException(nameof(assetName));
}
if (IsDisposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
// On some platforms, name and slash direction matter.
// We store the asset by a /-seperating key rather than how the
// path to the file was passed to us to avoid
// loading "content/asset1.xnb" and "content\\ASSET1.xnb" as if they were two
// different files. This matches stock XNA behavior.
// The dictionary will ignore case differences
var key = assetName.Replace('\\', '/');
// Check for a previously loaded asset first
if (LoadedAssets.TryGetValue(key, out var asset))
{
if (asset is T typedAsset)
{
return(typedAsset);
}
}
// Load the asset.
T result = ReadAsset <T>(assetName, null);
LoadedAssets[key] = result;
return(result);
}
} // Asset
#endregion
#region Dispose
/// <summary>
/// Dispose managed resources.
/// </summary>
protected override void DisposeManagedResources()
{
if (ContentManager != null)
throw new InvalidOperationException("Assets loaded with content managers cannot be disposed individually.");
LoadedAssets.Remove(this);
areLoadedAssetsSorted = false;
} // DisposeManagedResources
// loads a font
private void LoadFont(string assetName)
{
// load spritefont and create a new font
SpriteFont spriteFont = Load <SpriteFont>(assetName);
Font font = new Font(spriteFont);
LoadedAssets.Remove(assetName); // remove spritefont's reference from loaded assets
AddLoadedAsset(assetName, font); // add the font to the loaded assets
}
public override T Load <T>(string assetName)
{
if (Locked && !LoadedAssets.ContainsKey(assetName))
{
throw new ContentLockedException();
}
return(base.Load <T>(assetName));
}
// loads a sprite
private void LoadSprite(string assetName)
{
// load texture and create new sprite
Texture2D texture = Load <Texture2D>(assetName);
Sprite sprite = new Sprite(texture);
LoadedAssets.Remove(assetName); // remove texture's reference from loaded assets
AddLoadedAsset(assetName, sprite); // add the sprite to the loaded assets
}
} // SortedLoadedAssets
#endregion
#endregion
#region Constructor
protected Asset()
{
// Create a unique ID
Id = uniqueIdCounter;
uniqueIdCounter++;
LoadedAssets.Add(this);
areLoadedAssetsSorted = false;
if (AssetContentManager.CurrentContentManager == null)
throw new InvalidOperationException("Asset: The current content manager is null.");
ContentManager = AssetContentManager.CurrentContentManager;
} // Asset
public void Reset()
{
if (LoadedAssets == null)
{
LoadedAssets =
new Dictionary <AssetInfo, UnityObjectWrapper <GameObject> >(AssetInfo.AssetInfoComparer.Instance);
}
else
{
LoadedAssets.Clear();
}
}
public override T Load <T>(string assetName)
{
if (assetName == "DirectionalBlurShader")
{
return(default(T));
}
if (typeof(T) == typeof(IWcR2Font))
{
object value;
if (!LoadedAssets.TryGetValue(assetName, out value))
{
value = LoadXnaFont(assetName);
if (value != null)
{
LoadedAssets[assetName] = value;
}
}
return((T)value);
}
else if (typeof(T) == typeof(Texture2D))
{
object value;
if (!LoadedAssets.TryGetValue(assetName, out value))
{
var bitmap = MRes.ResourceManager.GetObject(assetName) as System.Drawing.Bitmap;
if (bitmap == null)
{
var obj = Res.ResourceManager.GetObject(assetName);
bitmap = Res.ResourceManager.GetObject(assetName) as System.Drawing.Bitmap;
}
if (bitmap != null)
{
value = bitmap.ToTexture(this.GraphicsDevice);
}
else //寻找wz
{
var png = PluginBase.PluginManager.FindWz(assetName).GetValueEx <Wz_Png>(null);
if (png != null)
{
value = png.ToTexture(this.GraphicsDevice);
}
}
if (value != null)
{
LoadedAssets[assetName] = value;
}
}
return((T)value);
}
return(base.Load <T>(assetName));
}
public bool AddLoadingAssets(AssetInfo assetInfo)
{
UnityObject uo;
LoadedAssets.TryGetValue(assetInfo, out uo);
if (uo == null)
{
loadingAssetInfos.Add(assetInfo);
return(true);
}
return(false);
}
/// <summary>
/// Gets the asset with the given name
/// names are to be fornmatted as such:
/// pack:dir/subdir/file
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <returns></returns>
public T GetAsset <T>(string name)
{
object asset;
if (LoadedAssets.TryGetValue(name, out asset))
{
if (typeof(T) == typeof(Stream))
{
((Stream)asset).Position = 0;
}
return((T)asset);
}
ConsoleManager.Instance.WriteLine($"Attempting to access an asset that does not exist '{name}'");
return(default(T));
}
/// <summary>
/// reverse lookup. Gets the asset path given the asset. This is useful for making editor and non-runtime stuff.
/// </summary>
/// <param name="asset"></param>
/// <returns></returns>
public string GetPathForLoadedAsset(object asset)
{
if (LoadedAssets.ContainsValue(asset))
{
foreach (var kv in LoadedAssets)
{
if (kv.Value == asset)
{
return(kv.Key);
}
}
}
return(null);
}
} // CompareAssets
#endregion
#region Set Unique Name
/// <summary>
/// Set a unique texture name.
/// </summary>
public void SetUniqueName(string newName)
{
// Is the name unique?
bool isUnique = LoadedAssets.All(assetFromList => assetFromList == this || assetFromList.Name != newName);
if (isUnique)
{
if (name != newName)
{
name = newName;
areLoadedAssetsSorted = false;
}
}
// If not then we add one to its name and search again to see if is unique.
else
SetUniqueName(newName.PlusOne());
} // SetUniqueName
/// <summary>
/// Loads a SpriteAtlas created with the Sprite Atlas Packer tool
/// </summary>
public SpriteAtlas LoadSpriteAtlas(string name, bool premultiplyAlpha = false)
{
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is SpriteAtlas spriteAtlas)
{
return(spriteAtlas);
}
}
var atlas = SpriteAtlasLoader.ParseSpriteAtlas(name, premultiplyAlpha);
LoadedAssets.Add(name, atlas);
DisposableAssets.Add(atlas);
return(atlas);
}
/// <summary>
/// Loads a BitmapFont
/// </summary>
public BitmapFont LoadBitmapFont(string name)
{
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is BitmapFont bmFont)
{
return(bmFont);
}
}
var font = BitmapFontLoader.LoadFontFromFile(name);
LoadedAssets.Add(name, font);
DisposableAssets.Add(font);
return(font);
}
/// <summary>
/// loads a Tiled map
/// </summary>
public TmxMap LoadTiledMap(string name)
{
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is TmxMap map)
{
return(map);
}
}
var tiledMap = new TmxMap().LoadTmxMap(name);
LoadedAssets[name] = tiledMap;
DisposableAssets.Add(tiledMap);
return(tiledMap);
}
public override T Load <T>(string assetName)
{
if (typeof(T) == typeof(XnaFont))
{
object value;
if (!LoadedAssets.TryGetValue(assetName, out value))
{
value = LoadXnaFont(assetName);
if (value != null)
{
LoadedAssets[assetName] = value;
}
}
return((T)value);
}
return(base.Load <T>(assetName));
}
public override T Load <T>(string cvarAssetName)
{
string assetName;
try
{
assetName = CVars.Get <string>(cvarAssetName);
} catch (Exception)
{
throw new Exception(string.Format("Can not load content (CVar does not exist): `${0}`.", cvarAssetName));
}
if (Locked && !LoadedAssets.ContainsKey(assetName))
{
throw new ContentLockedException();
}
return(base.Load <T>(assetName));
}
private void Start()
{
_levelInfoLoader = new LevelNodesLoader();
popupManager = FindObjectOfType <PopupManager>();
_levelEventsLoader = new LevelEventLoader();
_minionJSONLoader = new MinionsJsonLoaderManager();
_towerJSONLoader = new TowerJSONLoaderManager();
_user = new User(this);
_currentViewingWorld = _user.LevelProgressManager.GetCurrentUserWorldIndex();
tutorialManager.Init(this);
_libraryManager = new LibraryManager(this);
_loadedAssets = FindObjectOfType <LoadedAssets>();
SceneManager.sceneUnloaded += SceneUnloaded;
}
public void AddReplacer(AssetsReplacer replacer, MemoryStream previewStream = null)
{
if (replacer == null)
{
return;
}
var forInstance = LoadedFiles[replacer.GetFileID()];
var assetId = new AssetID(forInstance.path, replacer.GetPathID());
var index = LoadedAssets.FindIndex(i => i.FileID == replacer.GetFileID() && i.PathID == replacer.GetPathID());
var item = LoadedAssets[index];
if (NewAssets.ContainsKey(assetId))
{
RemoveReplacer(replacer);
}
NewAssets[assetId] = replacer;
if (previewStream == null)
{
var newStream = new MemoryStream();
var newWriter = new AssetsFileWriter(newStream);
replacer.Write(newWriter);
newStream.Position = 0;
previewStream = newStream;
}
NewAssetDatas[assetId] = previewStream;
if (replacer is AssetsRemover)
{
LoadedContainers.Remove(assetId);
}
else
{
var cont = MakeAssetContainer(item, NewAssetDatas[assetId]);
UpdateAssetInfo(cont, assetId, index);
}
Modified = true;
}
/// <summary>
/// removes assetName from LoadedAssets and Disposes of it
/// disposeableAssets List.
/// </summary>
/// <param name="assetName">Asset name.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public void UnloadAsset <T>(string assetName) where T : class, IDisposable
{
if (IsAssetLoaded(assetName))
{
// first fetch the actual asset. we already know its loaded so we'll grab it directly
var assetToRemove = LoadedAssets[assetName];
for (var i = 0; i < DisposableAssets.Count; i++)
{
// see if the asset is disposeable. If so, find and dispose of it.
var typedAsset = DisposableAssets[i] as T;
if (typedAsset != null && typedAsset == assetToRemove)
{
typedAsset.Dispose();
DisposableAssets.RemoveAt(i);
break;
}
}
LoadedAssets.Remove(assetName);
}
}
public void AddReplacer(AssetsFileInstance forFile, AssetsReplacer replacer, Stream? previewStream = null)
{
AssetsFile assetsFile = forFile.file;
AssetID assetId = new AssetID(forFile.path, replacer.GetPathID());
if (NewAssets.ContainsKey(assetId))
RemoveReplacer(forFile, NewAssets[assetId], true);
NewAssets[assetId] = replacer;
//make stream to use as a replacement to the one from file
if (previewStream == null)
{
MemoryStream newStream = new MemoryStream();
AssetsFileWriter newWriter = new AssetsFileWriter(newStream);
replacer.Write(newWriter);
newStream.Position = 0;
previewStream = newStream;
}
NewAssetDatas[assetId] = previewStream;
if (!(replacer is AssetsRemover))
{
AssetsFileReader reader = new AssetsFileReader(previewStream);
AssetContainer cont = new AssetContainer(
reader, 0, replacer.GetPathID(), (uint)replacer.GetClassID(),
replacer.GetMonoScriptID(), (uint)previewStream.Length, forFile);
LoadedAssets[assetId] = cont;
}
else
{
LoadedAssets.Remove(assetId);
}
if (ItemUpdated != null)
ItemUpdated(forFile, assetId);
Modified = true;
}
/// <summary>
/// Load a sound effect from xnb or wav
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public SoundEffect LoadSoundEffect(string name)
{
if (string.IsNullOrEmpty(Path.GetExtension(name)))
{
return(Load <SoundEffect>(name));
}
if (LoadedAssets.TryGetValue(name, out var asset))
{
if (asset is SoundEffect sfx)
{
return(sfx);
}
}
using (var stream = Path.IsPathRooted(name) ? File.OpenRead(name) : TitleContainer.OpenStream(name))
{
var sfx = SoundEffect.FromStream(stream);
LoadedAssets[name] = sfx;
DisposableAssets.Add(sfx);
return(sfx);
}
}