epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use IReadOnlyFileSystem in artwork loaders.

Browse Source
This commit is contained in:
Paul Chote
2016-02-15 01:04:00 +00:00
parent a1bc70cb58
commit b347fade71
15 changed files with 70 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
OpenRA.Game/GameRules/RulesetCache.cs
View File

@@ -11,6 +11,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OpenRA.FileSystem;
using OpenRA.GameRules;
using OpenRA.Graphics;
using OpenRA.Support;
@@ -47,7 +48,7 @@ namespace OpenRA
/// Cache and return the Ruleset for a given map.
/// If a map isn't specified then return the default mod Ruleset.
/// </summary>
public Ruleset Load(Map map = null)
public Ruleset Load(IReadOnlyFileSystem fileSystem, Map map = null)
{
var m = modData.Manifest;
@@ -59,38 +60,38 @@ namespace OpenRA
Dictionary<string, TileSet> tileSets;
using (new PerfTimer("Actors"))
actors = LoadYamlRules(actorCache, m.Rules,
actors = LoadYamlRules(fileSystem, actorCache, m.Rules,
map != null ? map.RuleDefinitions : NoMapRules,
k => new ActorInfo(Game.ModData.ObjectCreator, k.Key.ToLowerInvariant(), k.Value));
using (new PerfTimer("Weapons"))
weapons = LoadYamlRules(weaponCache, m.Weapons,
weapons = LoadYamlRules(fileSystem, weaponCache, m.Weapons,
map != null ? map.WeaponDefinitions : NoMapRules,
k => new WeaponInfo(k.Key.ToLowerInvariant(), k.Value));
using (new PerfTimer("Voices"))
voices = LoadYamlRules(voiceCache, m.Voices,
voices = LoadYamlRules(fileSystem, voiceCache, m.Voices,
map != null ? map.VoiceDefinitions : NoMapRules,
k => new SoundInfo(k.Value));
using (new PerfTimer("Notifications"))
notifications = LoadYamlRules(notificationCache, m.Notifications,
notifications = LoadYamlRules(fileSystem, notificationCache, m.Notifications,
map != null ? map.NotificationDefinitions : NoMapRules,
k => new SoundInfo(k.Value));
using (new PerfTimer("Music"))
music = LoadYamlRules(musicCache, m.Music,
music = LoadYamlRules(fileSystem, musicCache, m.Music,
map != null ? map.MusicDefinitions : NoMapRules,
k => new MusicInfo(k.Key, k.Value));
using (new PerfTimer("TileSets"))
tileSets = LoadTileSets(tileSetCache, sequenceCaches, m.TileSets);
tileSets = LoadTileSets(fileSystem, tileSetCache, sequenceCaches, m.TileSets);
var sequences = sequenceCaches.ToDictionary(kvp => kvp.Key, kvp => new SequenceProvider(kvp.Value, map));
var sequences = sequenceCaches.ToDictionary(kvp => kvp.Key, kvp => new SequenceProvider(fileSystem, kvp.Value, map));
return new Ruleset(actors, weapons, voices, notifications, music, tileSets, sequences);
}
Dictionary<string, T> LoadYamlRules<T>(
Dictionary<string, T> LoadYamlRules<T>(IReadOnlyFileSystem fileSystem,
Dictionary<string, T> itemCache,
string[] files, List<MiniYamlNode> nodes,
Func<MiniYamlNode, T> f)
@@ -112,7 +113,7 @@ namespace OpenRA
return t;
};
var tree = MiniYaml.Merge(files.Select(s => MiniYaml.FromStream(modData.ModFiles.Open(s))).Append(nodes))
var tree = MiniYaml.Merge(files.Select(s => MiniYaml.FromStream(fileSystem.Open(s))).Append(nodes))
.ToDictionaryWithConflictLog(n => n.Key, n => n.Value, "LoadYamlRules", null, null);
RaiseProgress();
@@ -121,7 +122,7 @@ namespace OpenRA
return itemSet;
}
Dictionary<string, TileSet> LoadTileSets(Dictionary<string, TileSet> itemCache, Dictionary<string, SequenceCache> sequenceCaches, string[] files)
Dictionary<string, TileSet> LoadTileSets(IReadOnlyFileSystem fileSystem, Dictionary<string, TileSet> itemCache, Dictionary<string, SequenceCache> sequenceCaches, string[] files)
{
var items = new Dictionary<string, TileSet>();
@@ -136,7 +137,7 @@ namespace OpenRA
itemCache.Add(file, t);
// every time we load a tile set, we create a sequence cache for it
var sc = new SequenceCache(modData, t);
var sc = new SequenceCache(modData, fileSystem, t);
sequenceCaches.Add(t.Id, sc);
items.Add(t.Id, t);

7
OpenRA.Game/Graphics/CursorProvider.cs
View File

@@ -21,8 +21,9 @@ namespace OpenRA.Graphics
public CursorProvider(ModData modData)
{
var fileSystem = modData.DefaultFileSystem;
var sequenceYaml = MiniYaml.Merge(modData.Manifest.Cursors.Select(
s => MiniYaml.FromStream(modData.ModFiles.Open(s))));
s => MiniYaml.FromStream(fileSystem.Open(s))));
var shadowIndex = new int[] { };
@@ -36,11 +37,11 @@ namespace OpenRA.Graphics
var palettes = new Dictionary<string, ImmutablePalette>();
foreach (var p in nodesDict["Palettes"].Nodes)
palettes.Add(p.Key, new ImmutablePalette(modData.ModFiles.Open(p.Value.Value), shadowIndex));
palettes.Add(p.Key, new ImmutablePalette(fileSystem.Open(p.Value.Value), shadowIndex));
Palettes = palettes.AsReadOnly();
var frameCache = new FrameCache(modData.SpriteLoaders);
var frameCache = new FrameCache(fileSystem, modData.SpriteLoaders);
var cursors = new Dictionary<string, CursorSequence>();
foreach (var s in nodesDict["Cursors"].Nodes)
foreach (var sequence in s.Value.Nodes)

17
OpenRA.Game/Graphics/SequenceProvider.cs
View File

@@ -11,6 +11,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OpenRA.FileSystem;
namespace OpenRA.Graphics
{
@@ -46,9 +47,9 @@ namespace OpenRA.Graphics
readonly Lazy<Sequences> sequences;
public readonly SpriteCache SpriteCache;
public SequenceProvider(SequenceCache cache, Map map)
public SequenceProvider(IReadOnlyFileSystem fileSystem, SequenceCache cache, Map map)
{
sequences = Exts.Lazy(() => cache.LoadSequences(map));
sequences = Exts.Lazy(() => cache.LoadSequences(fileSystem, map));
SpriteCache = cache.SpriteCache;
}
@@ -106,25 +107,25 @@ namespace OpenRA.Graphics
readonly Dictionary<string, UnitSequences> sequenceCache = new Dictionary<string, UnitSequences>();
public SequenceCache(ModData modData, TileSet tileSet)
public SequenceCache(ModData modData, IReadOnlyFileSystem fileSystem, TileSet tileSet)
{
this.modData = modData;
this.tileSet = tileSet;
// Every time we load a tile set, we create a sequence cache for it
spriteCache = Exts.Lazy(() => new SpriteCache(modData.SpriteLoaders, new SheetBuilder(SheetType.Indexed)));
spriteCache = Exts.Lazy(() => new SpriteCache(fileSystem, modData.SpriteLoaders, new SheetBuilder(SheetType.Indexed)));
}
public Sequences LoadSequences(Map map)
public Sequences LoadSequences(IReadOnlyFileSystem fileSystem, Map map)
{
using (new Support.PerfTimer("LoadSequences"))
return Load(map != null ? map.SequenceDefinitions : new List<MiniYamlNode>());
return Load(fileSystem, map != null ? map.SequenceDefinitions : new List<MiniYamlNode>());
}
Sequences Load(List<MiniYamlNode> sequenceNodes)
Sequences Load(IReadOnlyFileSystem fileSystem, List<MiniYamlNode> sequenceNodes)
{
var nodes = MiniYaml.Merge(modData.Manifest.Sequences
.Select(s => MiniYaml.FromStream(modData.ModFiles.Open(s)))
.Select(s => MiniYaml.FromStream(fileSystem.Open(s)))
.Append(sequenceNodes));
var items = new Dictionary<string, UnitSequences>();

17
OpenRA.Game/Graphics/SpriteLoader.cs
View File

@@ -11,6 +11,7 @@
using System.Drawing;
using System.IO;
using System.Linq;
using OpenRA.FileSystem;
using OpenRA.Primitives;
namespace OpenRA.Graphics
@@ -34,11 +35,11 @@ namespace OpenRA.Graphics
public readonly SheetBuilder SheetBuilder;
readonly Cache<string, Sprite[]> sprites;
public SpriteCache(ISpriteLoader[] loaders, SheetBuilder sheetBuilder)
public SpriteCache(IReadOnlyFileSystem fileSystem, ISpriteLoader[] loaders, SheetBuilder sheetBuilder)
{
SheetBuilder = sheetBuilder;
sprites = new Cache<string, Sprite[]>(filename => SpriteLoader.GetSprites(filename, loaders, sheetBuilder));
sprites = new Cache<string, Sprite[]>(filename => SpriteLoader.GetSprites(fileSystem, filename, loaders, sheetBuilder));
}
public Sprite[] this[string filename] { get { return sprites[filename]; } }
@@ -48,9 +49,9 @@ namespace OpenRA.Graphics
{
readonly Cache<string, ISpriteFrame[]> frames;
public FrameCache(ISpriteLoader[] loaders)
public FrameCache(IReadOnlyFileSystem fileSystem, ISpriteLoader[] loaders)
{
frames = new Cache<string, ISpriteFrame[]>(filename => SpriteLoader.GetFrames(filename, loaders));
frames = new Cache<string, ISpriteFrame[]>(filename => SpriteLoader.GetFrames(fileSystem, filename, loaders));
}
public ISpriteFrame[] this[string filename] { get { return frames[filename]; } }
@@ -58,14 +59,14 @@ namespace OpenRA.Graphics
public static class SpriteLoader
{
public static Sprite[] GetSprites(string filename, ISpriteLoader[] loaders, SheetBuilder sheetBuilder)
public static Sprite[] GetSprites(IReadOnlyFileSystem fileSystem, string filename, ISpriteLoader[] loaders, SheetBuilder sheetBuilder)
{
return GetFrames(filename, loaders).Select(a => sheetBuilder.Add(a)).ToArray();
return GetFrames(fileSystem, filename, loaders).Select(a => sheetBuilder.Add(a)).ToArray();
}
public static ISpriteFrame[] GetFrames(string filename, ISpriteLoader[] loaders)
public static ISpriteFrame[] GetFrames(IReadOnlyFileSystem fileSystem, string filename, ISpriteLoader[] loaders)
{
using (var stream = Game.ModData.ModFiles.Open(filename))
using (var stream = fileSystem.Open(filename))
{
ISpriteFrame[] frames;
foreach (var loader in loaders)

2
OpenRA.Game/Graphics/Theater.cs
View File

@@ -56,7 +56,7 @@ namespace OpenRA.Graphics
sheetBuilder = new SheetBuilder(type, allocate);
random = new MersenneTwister();
var frameCache = new FrameCache(Game.ModData.SpriteLoaders);
var frameCache = new FrameCache(Game.ModData.DefaultFileSystem, Game.ModData.SpriteLoaders);
foreach (var t in tileset.Templates)
{
var variants = new List<Sprite[]>();

2
OpenRA.Game/Map/Map.cs
View File

@@ -372,7 +372,7 @@ namespace OpenRA
{
try
{
return Game.ModData.RulesetCache.Load(this);
return Game.ModData.RulesetCache.Load(Game.ModData.DefaultFileSystem, this);
}
catch (Exception e)
{

2
OpenRA.Game/ModData.cs
View File

@@ -72,7 +72,7 @@ namespace OpenRA
SpriteSequenceLoader = (ISpriteSequenceLoader)ctor.Invoke(new[] { this });
SpriteSequenceLoader.OnMissingSpriteError = s => Log.Write("debug", s);
defaultRules = Exts.Lazy(() => RulesetCache.Load());
defaultRules = Exts.Lazy(() => RulesetCache.Load(DefaultFileSystem));
initialThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
}