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); } }