Merge FileFormats dll into Game and reorganise namespaces.

OpenRA.Game/Graphics/CursorProvider.cs

@@ -11,7 +11,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenRA.FileFormats;
+using OpenRA.FileSystem;
+using OpenRA.Primitives;
 
 namespace OpenRA.Graphics
 {
@@ -45,7 +46,7 @@ namespace OpenRA.Graphics
 
 			palette = new HardwarePalette();
 			foreach (var p in sequences.NodesDict["Palettes"].Nodes)
-				palette.AddPalette(p.Key, new Palette(FileSystem.Open(p.Value.Value), shadowIndex), false);
+				palette.AddPalette(p.Key, new Palette(GlobalFileSystem.Open(p.Value.Value), shadowIndex), false);
 
 			foreach (var s in sequences.NodesDict["Cursors"].Nodes)
 				LoadSequencesForCursor(s.Key, s.Value);

OpenRA.Game/Graphics/HSLColor.cs

@@ -0,0 +1,102 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Drawing;
+
+namespace OpenRA.Graphics
+{
+	public struct HSLColor
+	{
+		public readonly byte H;
+		public readonly byte S;
+		public readonly byte L;
+		public readonly Color RGB;
+
+		public static HSLColor FromHSV(float h, float s, float v)
+		{
+			var ll = 0.5f * (2 - s) * v;
+			var ss = (ll >= 1 || v <= 0) ? 0 : 0.5f * s * v / (ll <= 0.5f ? ll : 1 - ll);
+			return new HSLColor((byte)(255 * h), (byte)(255 * ss), (byte)(255 * ll));
+		}
+
+		public static HSLColor FromRGB(int r, int g, int b)
+		{
+			var c = Color.FromArgb(r, g, b);
+			var h = (byte)((c.GetHue() / 360.0f) * 255);
+			var s = (byte)(c.GetSaturation() * 255);
+			var l = (byte)(c.GetBrightness() * 255);
+			return new HSLColor(h, s, l);
+		}
+
+		public static Color RGBFromHSL(float h, float s, float l)
+		{
+			// Convert from HSL to RGB
+			var q = (l < 0.5f) ? l * (1 + s) : l + s - (l * s);
+			var p = 2 * l - q;
+
+			float[] trgb = { h + 1 / 3.0f, h, h - 1 / 3.0f };
+			float[] rgb = { 0, 0, 0 };
+
+			for (int k = 0; k < 3; k++)
+			{
+				while (trgb[k] < 0) trgb[k] += 1.0f;
+				while (trgb[k] > 1) trgb[k] -= 1.0f;
+			}
+
+			for (int k = 0; k < 3; k++)
+			{
+				if (trgb[k] < 1 / 6.0f) { rgb[k] = p + ((q - p) * 6 * trgb[k]); }
+				else if (trgb[k] >= 1 / 6.0f && trgb[k] < 0.5) { rgb[k] = q; }
+				else if (trgb[k] >= 0.5f && trgb[k] < 2.0f / 3) { rgb[k] = p + ((q - p) * 6 * (2.0f / 3 - trgb[k])); }
+				else { rgb[k] = p; }
+			}
+
+			return Color.FromArgb((int)(rgb[0] * 255), (int)(rgb[1] * 255), (int)(rgb[2] * 255));
+		}
+
+		public static bool operator ==(HSLColor me, HSLColor other)
+		{
+			return me.H == other.H && me.S == other.S && me.L == other.L;
+		}
+
+		public static bool operator !=(HSLColor me, HSLColor other) { return !(me == other); }
+
+		public HSLColor(byte h, byte s, byte l)
+		{
+			H = h;
+			S = s;
+			L = l;
+			RGB = RGBFromHSL(H / 255f, S / 255f, L / 255f);
+		}
+
+		public void ToHSV(out float h, out float s, out float v)
+		{
+			var ll = 2 * L / 255f;
+			var ss = S / 255f * ((ll <= 1) ? ll : 2 - ll);
+
+			h = H / 255f;
+			s = (2 * ss) / (ll + ss);
+			v = (ll + ss) / 2;
+		}
+
+		public override string ToString()
+		{
+			return "{0},{1},{2}".F(H, S, L);
+		}
+
+		public override int GetHashCode() { return H.GetHashCode() ^ S.GetHashCode() ^ L.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			var o = obj as HSLColor?;
+			return o != null && o == this;
+		}
+	}
+}

OpenRA.Game/Graphics/HardwarePalette.cs

@@ -12,7 +12,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Graphics

OpenRA.Game/Graphics/LineRenderer.cs

@@ -9,7 +9,6 @@
 #endregion
 
 using System.Drawing;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/MappedImage.cs

@@ -9,7 +9,6 @@
 #endregion
 
 using System.Drawing;
-using OpenRA.FileFormats;
 using System.Collections.Generic;
 
 namespace OpenRA.Graphics

OpenRA.Game/Graphics/Palette.cs

@@ -0,0 +1,126 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2012 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Reflection;
+
+namespace OpenRA.Graphics
+{
+	public class Palette
+	{
+		public static Palette Load(string filename, int[] remap)
+		{
+			using (var s = File.OpenRead(filename))
+				return new Palette(s, remap);
+		}
+
+		uint[] colors;
+		public Color GetColor(int index)
+		{
+			return Color.FromArgb((int)colors[index]);
+		}
+
+		public void SetColor(int index, Color color)
+		{
+			colors[index] = (uint)color.ToArgb();
+		}
+
+		public void SetColor(int index, uint color)
+		{
+			colors[index] = (uint)color;
+		}
+
+		public uint[] Values
+		{
+			get { return colors; }
+		}
+
+		public void ApplyRemap(IPaletteRemap r)
+		{
+			for (int i = 0; i < 256; i++)
+				colors[i] = (uint)r.GetRemappedColor(Color.FromArgb((int)colors[i]), i).ToArgb();
+		}
+
+		public Palette(Stream s, int[] remapShadow)
+		{
+			colors = new uint[256];
+
+			using (BinaryReader reader = new BinaryReader(s))
+			{
+				for (int i = 0; i < 256; i++)
+				{
+					byte r = (byte)(reader.ReadByte() << 2);
+					byte g = (byte)(reader.ReadByte() << 2);
+					byte b = (byte)(reader.ReadByte() << 2);
+					colors[i] = (uint)((255 << 24) | (r << 16) | (g << 8) | b);
+				}
+			}
+
+			colors[0] = 0; // convert black background to transparency
+			foreach (int i in remapShadow)
+				colors[i] = 140u << 24;
+		}
+
+		public Palette(Palette p, IPaletteRemap r)
+		{
+			colors = (uint[])p.colors.Clone();
+			ApplyRemap(r);
+		}
+
+		public Palette(Palette p)
+		{
+			colors = (uint[])p.colors.Clone();
+		}
+
+		public Palette(uint[] data)
+		{
+			if (data.Length != 256)
+				throw new InvalidDataException("Attempting to create palette with incorrect array size");
+			colors = (uint[])data.Clone();
+		}
+
+		public ColorPalette AsSystemPalette()
+		{
+			ColorPalette pal;
+			using (var b = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
+				pal = b.Palette;
+
+			for (var i = 0; i < 256; i++)
+				pal.Entries[i] = GetColor(i);
+
+			// hack around a mono bug -- the palette flags get set wrong.
+			if (Platform.CurrentPlatform != PlatformType.Windows)
+				typeof(ColorPalette).GetField("flags",
+					BindingFlags.Instance | BindingFlags.NonPublic).SetValue(pal, 1);
+
+			return pal;
+		}
+
+		public Bitmap AsBitmap()
+		{
+			var b = new Bitmap(256, 1, PixelFormat.Format32bppArgb);
+			var data = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
+								  ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
+			unsafe
+			{
+				uint* c = (uint*)data.Scan0;
+				for (var x = 0; x < 256; x++)
+					*(c + x) = colors[x];
+			}
+
+			b.UnlockBits(data);
+			return b;
+		}
+	}
+
+	public interface IPaletteRemap { Color GetRemappedColor(Color original, int index); }
+}

OpenRA.Game/Graphics/PlayerColorRemap.cs

@@ -0,0 +1,56 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using OpenRA.Primitives;
+
+namespace OpenRA.Graphics
+{
+	public class PlayerColorRemap : IPaletteRemap
+	{
+		Dictionary<int, Color> remapColors;
+
+		public static int GetRemapIndex(int[] ramp, int i)
+		{
+			return ramp[i];
+		}
+
+		public PlayerColorRemap(int[] ramp, HSLColor c, float rampFraction)
+		{
+			// Increase luminosity if required to represent the full ramp
+			var rampRange = (byte)((1 - rampFraction) * c.L);
+			var c1 = new HSLColor(c.H, c.S, (byte)Math.Max(rampRange, c.L)).RGB;
+			var c2 = new HSLColor(c.H, c.S, (byte)Math.Max(0, c.L - rampRange)).RGB;
+			var baseIndex = ramp[0];
+			var remapRamp = ramp.Select(r => r - ramp[0]).ToArray();
+
+			// reversed remapping
+			if (ramp[0] > ramp[15])
+			{
+				baseIndex = ramp[15];
+				for (var i = 15; i > 0; i--)
+					remapRamp = ramp.Select(r => r - ramp[15]).ToArray();
+			}
+			
+			remapColors = remapRamp.Select((x, i) => Pair.New(baseIndex + i, Exts.ColorLerp(x / 16f, c1, c2)))
+				.ToDictionary(u => u.First, u => u.Second);
+		}
+
+		public Color GetRemappedColor(Color original, int index)
+		{
+			Color c;
+			return remapColors.TryGetValue(index, out c)
+				? c : original;
+		}
+	}
+}

OpenRA.Game/Graphics/QuadRenderer.cs

@@ -9,7 +9,6 @@
 #endregion
 
 using System.Drawing;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/Renderer.cs

@@ -15,8 +15,6 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Windows.Forms;
-using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
 using OpenRA.Support;
 
 namespace OpenRA.Graphics

OpenRA.Game/Graphics/Sequence.cs

@@ -10,8 +10,6 @@
 
 using System;
 using System.Linq;
-using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/Sheet.cs

@@ -12,7 +12,7 @@ using System;
 using System.Drawing;
 using System.Drawing.Imaging;
 using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
+using OpenRA.FileSystem;
 
 namespace OpenRA.Graphics
 {
@@ -39,7 +39,7 @@ namespace OpenRA.Graphics
 
 		public Sheet(string filename)
 		{
-			var bitmap = (Bitmap)Image.FromStream(FileSystem.Open(filename));
+			var bitmap = (Bitmap)Image.FromStream(GlobalFileSystem.Open(filename));
 			Size = bitmap.Size;
 
 			data = new byte[4*Size.Width*Size.Height];

OpenRA.Game/Graphics/SheetBuilder.cs

@@ -11,7 +11,6 @@
 using System;
 using System.Drawing;
 using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/Sprite.cs

@@ -9,7 +9,6 @@
 #endregion
 
 using System.Drawing;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/SpriteFont.cs

@@ -11,8 +11,9 @@
 using System;
 using System.Drawing;
 using System.Linq;
-using OpenRA.FileFormats;
 using SharpFont;
+using OpenRA.FileFormats;
+using OpenRA.Primitives;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/SpriteLoader.cs

@@ -11,6 +11,8 @@
 using System.IO;
 using System.Linq;
 using OpenRA.FileFormats;
+using OpenRA.FileSystem;
+using OpenRA.Primitives;
 
 namespace OpenRA.Graphics
 {
@@ -31,7 +33,7 @@ namespace OpenRA.Graphics
 
 		Sprite[] CacheSpriteFrames(string filename)
 		{
-			var stream = FileSystem.OpenWithExts(filename, exts);
+			var stream = GlobalFileSystem.OpenWithExts(filename, exts);
 			return SpriteSource.LoadSpriteSource(stream, filename).Frames
 				.Select(a => SheetBuilder.Add(a))
 				.ToArray();

OpenRA.Game/Graphics/SpriteRenderer.cs

@@ -9,7 +9,6 @@
 #endregion
 
 using System.Drawing;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/SpriteSource.cs

@@ -0,0 +1,266 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using OpenRA.FileFormats;
+
+namespace OpenRA.Graphics
+{
+	public interface ISpriteFrame
+	{
+		Size Size { get; }
+		Size FrameSize { get; }
+		float2 Offset { get; }
+		byte[] Data { get; }
+	}
+
+	public interface ISpriteSource
+	{
+		IEnumerable<ISpriteFrame> Frames { get; }
+		bool CacheWhenLoadingTileset { get; }
+	}
+
+	// TODO: Most of this should be moved into the format parsers themselves.
+	public enum SpriteType { Unknown, ShpTD, ShpTS, ShpD2, TmpTD, TmpRA, TmpTS, R8 }
+	public static class SpriteSource
+	{
+		static bool IsTmpRA(Stream s)
+		{
+			var start = s.Position;
+
+			s.Position += 20;
+			var a = s.ReadUInt32();
+			s.Position += 2;
+			var b = s.ReadUInt16();
+
+			s.Position = start;
+			return a == 0 && b == 0x2c73;
+		}
+
+		static bool IsTmpTD(Stream s)
+		{
+			var start = s.Position;
+
+			s.Position += 16;
+			var a = s.ReadUInt32();
+			var b = s.ReadUInt32();
+
+			s.Position = start;
+			return a == 0 && b == 0x0D1AFFFF;
+		}
+
+		static bool IsTmpTS(Stream s)
+		{
+			var start = s.Position;
+			s.Position += 8;
+			var sx = s.ReadUInt32();
+			var sy = s.ReadUInt32();
+
+			// Find the first frame
+			var offset = s.ReadUInt32();
+
+			if (offset > s.Length - 52)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			s.Position = offset + 12;
+			var test = s.ReadUInt32();
+
+			s.Position = start;
+			return test == sx * sy / 2 + 52;
+		}
+
+		static bool IsShpTS(Stream s)
+		{
+			var start = s.Position;
+
+			// First word is zero
+			if (s.ReadUInt16() != 0)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Sanity Check the image count
+			s.Position += 4;
+			var imageCount = s.ReadUInt16();
+			if (s.Position + 24 * imageCount > s.Length)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Check the size and format flag
+			// Some files define bogus frames, so loop until we find a valid one
+			s.Position += 4;
+			ushort w, h, f = 0;
+			byte type;
+			do
+			{
+				w = s.ReadUInt16();
+				h = s.ReadUInt16();
+				type = s.ReadUInt8();
+			}
+			while (w == 0 && h == 0 && f++ < imageCount);
+
+			s.Position = start;
+			return type < 4;
+		}
+
+		static bool IsShpTD(Stream s)
+		{
+			var start = s.Position;
+
+			// First word is the image count
+			var imageCount = s.ReadUInt16();
+			if (imageCount == 0)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Last offset should point to the end of file
+			var finalOffset = start + 14 + 8 * imageCount;
+			if (finalOffset > s.Length)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			s.Position = finalOffset;
+			var eof = s.ReadUInt32();
+			if (eof != s.Length)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Check the format flag on the first frame
+			s.Position = start + 17;
+			var b = s.ReadUInt8();
+
+			s.Position = start;
+			return b == 0x20 || b == 0x40 || b == 0x80;
+		}
+
+		static bool IsShpD2(Stream s)
+		{
+			var start = s.Position;
+
+			// First word is the image count
+			var imageCount = s.ReadUInt16();
+			if (imageCount == 0)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Test for two vs four byte offset
+			var testOffset = s.ReadUInt32();
+			var offsetSize = (testOffset & 0xFF0000) > 0 ? 2 : 4;
+
+			// Last offset should point to the end of file
+			var finalOffset = start + 2 + offsetSize * imageCount;
+			if (finalOffset > s.Length)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			s.Position = finalOffset;
+			var eof = offsetSize == 2 ? s.ReadUInt16() : s.ReadUInt32();
+			if (eof + 2 != s.Length)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Check the format flag on the first frame
+			var b = s.ReadUInt16();
+			s.Position = start;
+			return b == 5 || b <= 3;
+		}
+
+		static bool IsR8(Stream s)
+		{
+			var start = s.Position;
+
+			// First byte is nonzero
+			if (s.ReadUInt8() == 0)
+			{
+				s.Position = start;
+				return false;
+			}
+
+			// Check the format of the first frame
+			s.Position = start + 25;
+			var d = s.ReadUInt8();
+
+			s.Position = start;
+			return d == 8;
+		}
+
+		public static SpriteType DetectSpriteType(Stream s)
+		{
+			if (IsShpTD(s))
+				return SpriteType.ShpTD;
+
+			if (IsShpTS(s))
+				return SpriteType.ShpTS;
+
+			if (IsR8(s))
+				return SpriteType.R8;
+
+			if (IsTmpRA(s))
+				return SpriteType.TmpRA;
+
+			if (IsTmpTD(s))
+				return SpriteType.TmpTD;
+
+			if (IsTmpTS(s))
+				return SpriteType.TmpTS;
+
+			if (IsShpD2(s))
+				return SpriteType.ShpD2;
+
+			return SpriteType.Unknown;
+		}
+
+		public static ISpriteSource LoadSpriteSource(Stream s, string filename)
+		{
+			var type = DetectSpriteType(s);
+			switch (type)
+			{
+				case SpriteType.ShpTD:
+					return new ShpReader(s);
+				case SpriteType.ShpTS:
+					return new ShpTSReader(s);
+				case SpriteType.R8:
+					return new R8Reader(s);
+				case SpriteType.TmpRA:
+					return new TmpRAReader(s);
+				case SpriteType.TmpTD:
+					return new TmpTDReader(s);
+				case SpriteType.TmpTS:
+					return new TmpTSReader(s);
+				case SpriteType.ShpD2:
+					return new ShpD2Reader(s);
+				case SpriteType.Unknown:
+				default:
+					throw new InvalidDataException(filename + " is not a valid sprite file");
+			}
+		}
+	}
+}

OpenRA.Game/Graphics/TerrainRenderer.cs

@@ -8,7 +8,6 @@
  */
 #endregion
 
-using OpenRA.FileFormats.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Graphics

OpenRA.Game/Graphics/Theater.cs

@@ -13,7 +13,7 @@ using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
 using System.Linq;
-using OpenRA.FileFormats;
+using OpenRA.FileSystem;
 
 namespace OpenRA.Graphics
 {
@@ -28,7 +28,7 @@ namespace OpenRA.Graphics
 			ISpriteSource source;
 			if (!sourceCache.ContainsKey(filename))
 			{
-				using (var s = FileSystem.OpenWithExts(filename, exts))
+				using (var s = GlobalFileSystem.OpenWithExts(filename, exts))
 					source = SpriteSource.LoadSpriteSource(s, filename);
 
 				if (source.CacheWhenLoadingTileset)

OpenRA.Game/Graphics/Util.cs

@@ -11,7 +11,6 @@
 using System;
 using System.Drawing;
 using System.Drawing.Imaging;
-using OpenRA.FileFormats.Graphics;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/Vertex.cs

@@ -0,0 +1,35 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Runtime.InteropServices;
+
+namespace OpenRA.Graphics
+{
+	[StructLayout(LayoutKind.Sequential)]
+	public struct Vertex
+	{
+		public float x, y, z, u, v;
+		public float p, c;
+
+		public Vertex(float2 xy, float2 uv, float2 pc)
+		{
+			this.x = xy.X; this.y = xy.Y; this.z = 0;
+			this.u = uv.X; this.v = uv.Y;
+			this.p = pc.X; this.c = pc.Y;
+		}
+
+		public Vertex(float[] xyz, float2 uv, float2 pc)
+		{
+			this.x = xyz[0]; this.y = xyz[1]; this.z = xyz[2];
+			this.u = uv.X; this.v = uv.Y;
+			this.p = pc.X; this.c = pc.Y;
+		}
+	}
+}

OpenRA.Game/Graphics/VoxelLoader.cs

@@ -13,7 +13,8 @@ using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
+using OpenRA.FileSystem;
+using OpenRA.Primitives;
 
 namespace OpenRA.Graphics
 {
@@ -209,8 +210,8 @@ namespace OpenRA.Graphics
 
 		Voxel LoadFile(Pair<string,string> files)
 		{
-			var vxl = new VxlReader(FileSystem.OpenWithExts(files.First, ".vxl"));
-			var hva = new HvaReader(FileSystem.OpenWithExts(files.Second, ".hva"));
+			var vxl = new VxlReader(GlobalFileSystem.OpenWithExts(files.First, ".vxl"));
+			var hva = new HvaReader(GlobalFileSystem.OpenWithExts(files.Second, ".hva"));
 			return new Voxel(this, vxl, hva);
 		}
 

OpenRA.Game/Graphics/VoxelProvider.cs

@@ -12,7 +12,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using OpenRA.FileFormats;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/VoxelRenderer.cs

@@ -12,8 +12,7 @@ using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
-using OpenRA.FileFormats;
-using OpenRA.FileFormats.Graphics;
+using OpenRA.Primitives;
 
 namespace OpenRA.Graphics
 {

OpenRA.Game/Graphics/WorldRenderer.cs

@@ -13,6 +13,7 @@ using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 using OpenRA.FileFormats;
+using OpenRA.Primitives;
 using OpenRA.Traits;
 
 namespace OpenRA.Graphics