Merge pull request #3361 from pchote/voxels

TS/RA2 Voxel support

OpenRA.Game/Graphics/Renderer.cs

@@ -30,6 +30,7 @@ namespace OpenRA.Graphics
 		public SpriteRenderer WorldSpriteRenderer { get; private set; }
 		public QuadRenderer WorldQuadRenderer { get; private set; }
 		public LineRenderer WorldLineRenderer { get; private set; }
+		public VoxelRenderer WorldVoxelRenderer { get; private set; }
 		public LineRenderer LineRenderer { get; private set; }
 		public SpriteRenderer RgbaSpriteRenderer { get; private set; }
 		public SpriteRenderer SpriteRenderer { get; private set; }
@@ -46,6 +47,7 @@ namespace OpenRA.Graphics
 
 			WorldSpriteRenderer = new SpriteRenderer(this, device.CreateShader("shp"));
 			WorldLineRenderer = new LineRenderer(this, device.CreateShader("line"));
+			WorldVoxelRenderer = new VoxelRenderer(this, device.CreateShader("vxl"), device.CreateShader("vxlshadow"));
 			LineRenderer = new LineRenderer(this, device.CreateShader("line"));
 			WorldQuadRenderer = new QuadRenderer(this, device.CreateShader("line"));
 			RgbaSpriteRenderer = new SpriteRenderer(this, device.CreateShader("rgba"));
@@ -71,6 +73,7 @@ namespace OpenRA.Graphics
 			WorldLineRenderer.SetViewportParams(Resolution, zoom, scroll);
 			WorldQuadRenderer.SetViewportParams(Resolution, zoom, scroll);
 			LineRenderer.SetViewportParams(Resolution, 1f, float2.Zero);
+			WorldVoxelRenderer.SetViewportParams(Resolution, zoom, scroll);
 		}
 
 		ITexture currentPaletteTexture;
@@ -85,6 +88,7 @@ namespace OpenRA.Graphics
 			RgbaSpriteRenderer.SetPalette(currentPaletteTexture);
 			SpriteRenderer.SetPalette(currentPaletteTexture);
 			WorldSpriteRenderer.SetPalette(currentPaletteTexture);
+			WorldVoxelRenderer.SetPalette(currentPaletteTexture);
 		}
 
 		public void EndFrame(IInputHandler inputHandler)
@@ -186,5 +190,29 @@ namespace OpenRA.Graphics
 			Flush();
 			Device.DisableScissor();
 		}
+
+		public void EnableDepthBuffer()
+		{
+			Flush();
+			Device.EnableDepthBuffer();
+		}
+
+		public void DisableDepthBuffer()
+		{
+			Flush();
+			Device.DisableDepthBuffer();
+		}
+
+		public void EnableStencilBuffer()
+		{
+			Flush();
+			Device.EnableStencilBuffer();
+		}
+
+		public void DisableStencilBuffer()
+		{
+			Flush();
+			Device.DisableStencilBuffer();
+		}
 	}
 }

OpenRA.Game/Graphics/Util.cs

@@ -53,5 +53,181 @@ namespace OpenRA.Graphics
 				destOffset += destSkip;
 			}
 		}
+
+		public static float[] IdentityMatrix()
+		{
+			return Exts.MakeArray(16, j => (j % 5 == 0) ? 1.0f : 0);
+		}
+
+		public static float[] ScaleMatrix(float sx, float sy, float sz)
+		{
+			var mtx = IdentityMatrix();
+			mtx[0] = sx;
+			mtx[5] = sy;
+			mtx[10] = sz;
+			return mtx;
+		}
+
+		public static float[] TranslationMatrix(float x, float y, float z)
+		{
+			var mtx = IdentityMatrix();
+			mtx[12] = x;
+			mtx[13] = y;
+			mtx[14] = z;
+			return mtx;
+		}
+
+		public static float[] MatrixMultiply(float[] lhs, float[] rhs)
+		{
+			var mtx = new float[16];
+			for (var i = 0; i < 4; i++)
+			for (var j = 0; j < 4; j++)
+			{
+				mtx[4*i + j] = 0;
+				for (var k = 0; k < 4; k++)
+					mtx[4*i + j] += lhs[4*k + j]*rhs[4*i + k];
+			}
+
+			return mtx;
+		}
+
+		public static float[] MatrixVectorMultiply(float[] mtx, float[] vec)
+		{
+			var ret = new float[4];
+			for (var j = 0; j < 4; j++)
+			{
+				ret[j] = 0;
+				for (var k = 0; k < 4; k++)
+					ret[j] += mtx[4*k + j]*vec[k];
+			}
+
+			return ret;
+		}
+
+		public static float[] MatrixInverse(float[] m)
+		{
+			var mtx = new float[16];
+
+			mtx[0] = m[5]*m[10]*m[15] -
+				m[5]*m[11]*m[14] -
+				m[9]*m[6]*m[15] +
+				m[9]*m[7]*m[14] +
+				m[13]*m[6]*m[11] -
+				m[13]*m[7]*m[10];
+
+			mtx[4] = -m[4]*m[10]*m[15] +
+				m[4]*m[11]*m[14] +
+				m[8]*m[6]*m[15] -
+				m[8]*m[7]*m[14] -
+				m[12]*m[6]*m[11] +
+				m[12]*m[7]*m[10];
+
+			mtx[8] = m[4]*m[9]*m[15] -
+				m[4]*m[11]*m[13] -
+				m[8]*m[5]*m[15] +
+				m[8]*m[7]*m[13] +
+				m[12]*m[5]*m[11] -
+				m[12]*m[7]*m[9];
+
+			mtx[12] = -m[4]*m[9]*m[14] +
+				m[4]*m[10]*m[13] +
+				m[8]*m[5]*m[14] -
+				m[8]*m[6]*m[13] -
+				m[12]*m[5]*m[10] +
+				m[12]*m[6]*m[9];
+
+			mtx[1] = -m[1]*m[10]*m[15] +
+				m[1]*m[11]*m[14] +
+				m[9]*m[2]*m[15] -
+				m[9]*m[3]*m[14] -
+				m[13]*m[2]*m[11] +
+				m[13]*m[3]*m[10];
+
+			mtx[5] = m[0]*m[10]*m[15] -
+				m[0]*m[11]*m[14] -
+				m[8]*m[2]*m[15] +
+				m[8]*m[3]*m[14] +
+				m[12]*m[2]*m[11] -
+				m[12]*m[3]*m[10];
+
+			mtx[9] = -m[0]*m[9]*m[15] +
+				m[0]*m[11]*m[13] +
+				m[8]*m[1]*m[15] -
+				m[8]*m[3]*m[13] -
+				m[12]*m[1]*m[11] +
+				m[12]*m[3]*m[9];
+
+			mtx[13] = m[0]*m[9]*m[14] -
+				m[0]*m[10]*m[13] -
+				m[8]*m[1]*m[14] +
+				m[8]*m[2]*m[13] +
+				m[12]*m[1]*m[10] -
+				m[12]*m[2]*m[9];
+
+			mtx[2] = m[1]*m[6]*m[15] -
+				m[1]*m[7]*m[14] -
+				m[5]*m[2]*m[15] +
+				m[5]*m[3]*m[14] +
+				m[13]*m[2]*m[7] -
+				m[13]*m[3]*m[6];
+
+			mtx[6] = -m[0]*m[6]*m[15] +
+				m[0]*m[7]*m[14] +
+				m[4]*m[2]*m[15] -
+				m[4]*m[3]*m[14] -
+				m[12]*m[2]*m[7] +
+				m[12]*m[3]*m[6];
+
+			mtx[10] = m[0]*m[5]*m[15] -
+				m[0]*m[7]*m[13] -
+				m[4]*m[1]*m[15] +
+				m[4]*m[3]*m[13] +
+				m[12]*m[1]*m[7] -
+				m[12]*m[3]*m[5];
+
+			mtx[14] = -m[0]*m[5]*m[14] +
+				m[0]*m[6]*m[13] +
+				m[4]*m[1]*m[14] -
+				m[4]*m[2]*m[13] -
+				m[12]*m[1]*m[6] +
+				m[12]*m[2]*m[5];
+
+			mtx[3] = -m[1]*m[6]*m[11] +
+				m[1]*m[7]*m[10] +
+				m[5]*m[2]*m[11] -
+				m[5]*m[3]*m[10] -
+				m[9]*m[2]*m[7] +
+				m[9]*m[3]*m[6];
+
+			mtx[7] = m[0]*m[6]*m[11] -
+				m[0]*m[7]*m[10] -
+				m[4]*m[2]*m[11] +
+				m[4]*m[3]*m[10] +
+				m[8]*m[2]*m[7] -
+				m[8]*m[3]*m[6];
+
+			mtx[11] = -m[0]*m[5]*m[11] +
+				m[0]*m[7]*m[9] +
+				m[4]*m[1]*m[11] -
+				m[4]*m[3]*m[9] -
+				m[8]*m[1]*m[7] +
+				m[8]*m[3]*m[5];
+
+			mtx[15] = m[0]*m[5]*m[10] -
+				m[0]*m[6]*m[9] -
+				m[4]*m[1]*m[10] +
+				m[4]*m[2]*m[9] +
+				m[8]*m[1]*m[6] -
+				m[8]*m[2]*m[5];
+
+			var det = m[0]*mtx[0] + m[1]*mtx[4] + m[2]*mtx[8] + m[3]*mtx[12];
+			if (det == 0)
+				return null;
+
+			for (var i = 0; i < 16; i++)
+				mtx[i] *= 1/det;
+
+			return mtx;
+		}
 	}
 }

OpenRA.Game/Graphics/Voxel.cs

@@ -0,0 +1,161 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 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.FileFormats;
+using OpenRA.FileFormats.Graphics;
+
+namespace OpenRA.Graphics
+{
+	struct Limb
+	{
+		public float Scale;
+		public float[] Bounds;
+		public byte[] Size;
+		public VoxelRenderData RenderData;
+	}
+
+	public class Voxel
+	{
+		Limb[] limbs;
+		HvaReader hva;
+		VoxelLoader loader;
+
+		float[][] transform, lightDirection, groundNormal;
+		float[] groundZ;
+
+		public Voxel(VoxelLoader loader, VxlReader vxl, HvaReader hva)
+		{
+			this.hva = hva;
+			this.loader = loader;
+
+			limbs = new Limb[vxl.LimbCount];
+			for (var i = 0; i < vxl.LimbCount; i++)
+			{
+				var vl = vxl.Limbs[i];
+				var l = new Limb();
+				l.Scale = vl.Scale;
+				l.Bounds = (float[])vl.Bounds.Clone();
+				l.Size = (byte[])vl.Size.Clone();
+				l.RenderData = loader.GenerateRenderData(vxl.Limbs[i]);
+				limbs[i] = l;
+			}
+
+			transform = new float[vxl.LimbCount][];
+			lightDirection = new float[vxl.LimbCount][];
+			groundNormal = new float[vxl.LimbCount][];
+			groundZ = new float[vxl.LimbCount];
+		}
+
+		// Extract the rotation components from a matrix and apply them to a vector
+		static float[] ExtractRotationVector(float[] mtx, WVec vec)
+		{
+			var tVec = Util.MatrixVectorMultiply(mtx, new float[] {vec.X, vec.Y, vec.Z, 1});
+			var tOrigin = Util.MatrixVectorMultiply(mtx, new float[] {0,0,0,1});
+			tVec[0] -= tOrigin[0]*tVec[3]/tOrigin[3];
+			tVec[1] -= tOrigin[1]*tVec[3]/tOrigin[3];
+			tVec[2] -= tOrigin[2]*tVec[3]/tOrigin[3];
+
+			// Renormalize
+			var w = (float)Math.Sqrt(tVec[0]*tVec[0] + tVec[1]*tVec[1] + tVec[2]*tVec[2]);
+			tVec[0] /= w;
+			tVec[1] /= w;
+			tVec[2] /= w;
+			tVec[3] = 1f;
+
+			return tVec;
+		}
+
+		static float[] MakeFloatMatrix(int[] imtx)
+		{
+			var fmtx = new float[16];
+			for (var i = 0; i < 16; i++)
+				fmtx[i] = imtx[i]*1f / imtx[15];
+			return fmtx;
+		}
+
+		public void Draw(VoxelRenderer r, float[] lightAmbientColor, float[] lightDiffuseColor,
+		                 int colorPalette, int normalsPalette)
+		{
+			for (var i = 0; i < limbs.Length; i++)
+				r.Render(loader, limbs[i].RenderData, transform[i], lightDirection[i],
+				         lightAmbientColor, lightDiffuseColor, colorPalette, normalsPalette);
+		}
+
+		public void DrawShadow(VoxelRenderer r, int shadowPalette)
+		{
+			for (var i = 0; i < limbs.Length; i++)
+				r.RenderShadow(loader, limbs[i].RenderData, transform[i], lightDirection[i],
+				               groundNormal[i], groundZ[i], shadowPalette);
+		}
+
+		static readonly WVec forward = new WVec(1024,0,0);
+		static readonly WVec up = new WVec(0,0,1024);
+		public void PrepareForDraw(WorldRenderer wr, WPos pos, IEnumerable<WRot> rotations,
+		                           WRot camera, uint frame, float scale, WRot lightSource)
+		{
+			// Calculate the shared view matrix components
+			var pxPos = wr.ScreenPosition(pos);
+
+			// Rotations
+			var rot = rotations.Reverse().Aggregate(MakeFloatMatrix(camera.AsMatrix()),
+				(a,b) => Util.MatrixMultiply(a, MakeFloatMatrix(b.AsMatrix())));
+
+			// Each limb has its own transformation matrix
+			for (uint i = 0; i < limbs.Length; i++)
+			{
+				Limb l = limbs[i];
+				var t = Util.MatrixMultiply(Util.ScaleMatrix(1,-1,1),
+				                            hva.TransformationMatrix(i, frame));
+				// Fix limb position
+				t[12] *= l.Scale*(l.Bounds[3] - l.Bounds[0]) / l.Size[0];
+				t[13] *= l.Scale*(l.Bounds[4] - l.Bounds[1]) / l.Size[1];
+				t[14] *= l.Scale*(l.Bounds[5] - l.Bounds[2]) / l.Size[2];
+				t = Util.MatrixMultiply(t, Util.TranslationMatrix(l.Bounds[0], l.Bounds[1], l.Bounds[2]));
+
+				// Apply view matrix
+				transform[i] = Util.MatrixMultiply(Util.TranslationMatrix(pxPos.X, pxPos.Y, pxPos.Y),
+					Util.ScaleMatrix(scale*l.Scale, scale*l.Scale, scale*l.Scale));
+				transform[i] = Util.MatrixMultiply(transform[i], rot);
+				transform[i] = Util.MatrixMultiply(transform[i], t);
+
+				// Transform light direction into limb-space
+				var undoPitch = MakeFloatMatrix(new WRot(camera.Pitch, WAngle.Zero, WAngle.Zero).AsMatrix());
+				var lightTransform = Util.MatrixMultiply(Util.MatrixInverse(transform[i]), undoPitch);
+
+				lightDirection[i] = ExtractRotationVector(lightTransform, forward.Rotate(lightSource));
+				groundNormal[i] = ExtractRotationVector(Util.MatrixInverse(t), up);
+
+				// Hack: Extract the ground z position independently of y.
+				groundZ[i] = (wr.ScreenPosition(pos).Y - wr.ScreenZPosition(pos, 0)) / 2;
+			}
+		}
+
+		public uint Frames { get { return hva.FrameCount; }}
+		public uint LimbCount { get { return (uint)limbs.Length; }}
+
+		public float[] Size
+		{
+			get
+			{
+				return limbs.Select(a => a.Size.Select(b => a.Scale*b).ToArray())
+					.Aggregate((a,b) => new float[]
+					{
+						Math.Max(a[0], b[0]),
+						Math.Max(a[1], b[1]),
+						Math.Max(a[2], b[2])
+					});
+			}
+		}
+	}
+}

OpenRA.Game/Graphics/VoxelAnimation.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;
+using System.Collections.Generic;
+using OpenRA.Traits;
+
+namespace OpenRA.Graphics
+{
+	public struct VoxelAnimation
+	{
+		public readonly Voxel Voxel;
+		public readonly Func<WVec> OffsetFunc;
+		public readonly Func<IEnumerable<WRot>> RotationFunc;
+		public readonly Func<bool> DisableFunc;
+		public readonly Func<uint> FrameFunc;
+
+		public VoxelAnimation(Voxel voxel, Func<WVec> offset, Func<IEnumerable<WRot>> rotation, Func<bool> disable, Func<uint> frame)
+		{
+			Voxel = voxel;
+			OffsetFunc = offset;
+			RotationFunc = rotation;
+			DisableFunc = disable;
+			FrameFunc = frame;
+		}
+	}
+}
+

OpenRA.Game/Graphics/VoxelLoader.cs

@@ -0,0 +1,208 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 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.FileFormats;
+using OpenRA.FileFormats.Graphics;
+
+namespace OpenRA.Graphics
+{
+	public struct VoxelRenderData
+	{
+		public readonly int Start;
+		public readonly int Count;
+		public readonly Sheet Sheet;
+
+		public VoxelRenderData(int start, int count, Sheet sheet)
+		{
+			Start = start;
+			Count = count;
+			Sheet = sheet;
+		}
+	}
+
+	public class VoxelLoader
+	{
+		SheetBuilder sheetBuilder;
+
+		Cache<Pair<string,string>, Voxel> voxels;
+		IVertexBuffer<Vertex> vertexBuffer;
+		List<Vertex[]> vertices;
+		int totalVertexCount;
+		int cachedVertexCount;
+
+		public VoxelLoader()
+		{
+			voxels = new Cache<Pair<string,string>, Voxel>(LoadFile);
+			vertices = new List<Vertex[]>();
+			totalVertexCount = 0;
+			cachedVertexCount = 0;
+
+			sheetBuilder = new SheetBuilder(SheetType.DualIndexed);
+		}
+
+		static float[] channelSelect = { 0.75f, 0.25f, -0.25f, -0.75f };
+		Vertex[] GenerateSlicePlane(int su, int sv, Func<int,int,VxlElement> first, Func<int,int,VxlElement> second, Func<int, int, float[]> coord)
+		{
+			var colors = new byte[su*sv];
+			var normals = new byte[su*sv];
+
+			var c = 0;
+			for (var v = 0; v < sv; v++)
+				for (var u = 0; u < su; u++)
+			{
+				var voxel = first(u,v) ?? second(u,v);
+				colors[c] = voxel == null ? (byte)0 : voxel.Color;
+				normals[c] = voxel == null ? (byte)0 : voxel.Normal;
+				c++;
+			}
+
+			Sprite s = sheetBuilder.Allocate(new Size(su, sv), false);
+			Util.FastCopyIntoChannel(s, 0, colors);
+			Util.FastCopyIntoChannel(s, 1, normals);
+			s.sheet.MakeDirty();
+
+			var channels = new float2(channelSelect[(int)s.channel], channelSelect[(int)s.channel + 1]);
+			return new Vertex[4]
+			{
+				new Vertex(coord(0, 0), s.FastMapTextureCoords(0), channels),
+				new Vertex(coord(su, 0), s.FastMapTextureCoords(1), channels),
+				new Vertex(coord(su, sv), s.FastMapTextureCoords(3), channels),
+				new Vertex(coord(0, sv), s.FastMapTextureCoords(2), channels)
+			};
+		}
+
+		IEnumerable<Vertex[]> GenerateSlicePlanes(VxlLimb l)
+		{
+			Func<int,int,int,VxlElement> get = (x,y,z) =>
+			{
+				if (x < 0 || y < 0 || z < 0)
+					return null;
+
+				if (x >= l.Size[0] || y >= l.Size[1] || z >= l.Size[2])
+					return null;
+
+				var v = l.VoxelMap[(byte)x,(byte)y];
+				if (v == null || !v.ContainsKey((byte)z))
+					return null;
+
+				return l.VoxelMap[(byte)x,(byte)y][(byte)z];
+			};
+
+			// Cull slices without any visible faces
+			var xPlanes = new bool[l.Size[0]+1];
+			var yPlanes = new bool[l.Size[1]+1];
+			var zPlanes = new bool[l.Size[2]+1];
+			for (var x = 0; x < l.Size[0]; x++)
+			{
+				for (var y = 0; y < l.Size[1]; y++)
+				{
+					for (var z = 0; z < l.Size[2]; z++)
+					{
+						if (get(x,y,z) == null)
+							continue;
+
+						// Only generate a plane if it is actually visible
+						if (!xPlanes[x] && get(x-1,y,z) == null)
+							xPlanes[x] = true;
+						if (!xPlanes[x+1] && get(x+1,y,z) == null)
+							xPlanes[x+1] = true;
+
+						if (!yPlanes[y] && get(x,y-1,z) == null)
+							yPlanes[y] = true;
+						if (!yPlanes[y+1] && get(x,y+1,z) == null)
+							yPlanes[y+1] = true;
+
+						if (!zPlanes[z] && get(x,y,z-1) == null)
+							zPlanes[z] = true;
+						if (!zPlanes[z+1] && get(x,y,z+1) == null)
+							zPlanes[z+1] = true;
+					}
+				}
+			}
+
+			for (var x = 0; x <= l.Size[0]; x++)
+				if (xPlanes[x])
+					yield return GenerateSlicePlane(l.Size[1], l.Size[2],
+						(u,v) => get(x, u, v),
+						(u,v) => get(x - 1, u, v),
+						(u,v) => new float[] {x, u, v});
+
+			for (var y = 0; y <= l.Size[1]; y++)
+				if (yPlanes[y])
+					yield return GenerateSlicePlane(l.Size[0], l.Size[2],
+						(u,v) => get(u, y, v),
+						(u,v) => get(u, y - 1, v),
+						(u,v) => new float[] {u, y, v});
+
+			for (var z = 0; z <= l.Size[2]; z++)
+				if (zPlanes[z])
+					yield return GenerateSlicePlane(l.Size[0], l.Size[1],
+						(u,v) => get(u, v, z),
+						(u,v) => get(u, v, z - 1),
+						(u,v) => new float[] {u, v, z});
+		}
+
+		public VoxelRenderData GenerateRenderData(VxlLimb l)
+		{
+			Vertex[] v;
+			try
+			{
+				v = GenerateSlicePlanes(l).SelectMany(x => x).ToArray();
+			}
+			catch (SheetOverflowException)
+			{
+				// Sheet overflow - allocate a new sheet and try once more
+				Log.Write("debug", "Voxel sheet overflow! Generating new sheet");
+				sheetBuilder = new SheetBuilder(SheetType.DualIndexed);
+				v = GenerateSlicePlanes(l).SelectMany(x => x).ToArray();
+			}
+
+			vertices.Add(v);
+
+			var start = totalVertexCount;
+			var count = v.Length;
+			totalVertexCount += count;
+			return new VoxelRenderData(start, count, sheetBuilder.Current);
+		}
+
+		public void RefreshBuffer()
+		{
+			vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(totalVertexCount);
+			vertexBuffer.SetData(vertices.SelectMany(v => v).ToArray(), totalVertexCount);
+			cachedVertexCount = totalVertexCount;
+		}
+
+		public IVertexBuffer<Vertex> VertexBuffer
+		{
+			get
+			{
+				if (cachedVertexCount != totalVertexCount)
+					RefreshBuffer();
+				return vertexBuffer;
+			}
+		}
+
+		Voxel LoadFile(Pair<string,string> files)
+		{
+			var vxl = new VxlReader(FileSystem.OpenWithExts(files.First, ".vxl"));
+			var hva = new HvaReader(FileSystem.OpenWithExts(files.Second, ".hva"));
+			return new Voxel(this, vxl, hva);
+		}
+
+		public Voxel Load(string vxl, string hva)
+		{
+			return voxels[Pair.New(vxl, hva)];
+		}
+	}
+}

OpenRA.Game/Graphics/VoxelProvider.cs

@@ -0,0 +1,88 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 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.IO;
+using System.Linq;
+using OpenRA.FileFormats;
+
+namespace OpenRA.Graphics
+{
+	public static class VoxelProvider
+	{
+		static Dictionary<string, Dictionary<string, Voxel>> units;
+
+		public static void Initialize(string[] voxelFiles, List<MiniYamlNode> voxelNodes)
+		{
+			units = new Dictionary<string, Dictionary<string, Voxel>>();
+
+			var sequences = voxelFiles
+				.Select(s => MiniYaml.FromFile(s))
+				.Aggregate(voxelNodes, MiniYaml.MergeLiberal);
+
+			foreach (var s in sequences)
+				LoadVoxelsForUnit(s.Key, s.Value);
+
+			Game.modData.VoxelLoader.RefreshBuffer();
+		}
+
+		static Voxel LoadVoxel(string unit, string name, MiniYaml info)
+		{
+			var vxl = unit;
+			var hva = unit;
+			if (info.Value != null)
+			{
+				var fields = info.Value.Split(new char[] {','}, StringSplitOptions.RemoveEmptyEntries);
+				if (fields.Length >= 1)
+					vxl = hva = fields[0].Trim();
+
+				if (fields.Length >= 2)
+					hva = fields[1].Trim();
+			}
+
+			return Game.modData.VoxelLoader.Load(vxl, hva);
+		}
+
+		static void LoadVoxelsForUnit(string unit, MiniYaml sequences)
+		{
+			Game.modData.LoadScreen.Display();
+			try
+			{
+				var seq = sequences.NodesDict.ToDictionary(x => x.Key, x => LoadVoxel(unit,x.Key,x.Value));
+				units.Add(unit, seq);
+			}
+			catch (FileNotFoundException) {} // Do nothing; we can crash later if we actually wanted art
+		}
+
+		public static Voxel GetVoxel(string unitName, string voxelName)
+		{
+			try { return units[unitName][voxelName]; }
+			catch (KeyNotFoundException)
+			{
+				if (units.ContainsKey(unitName))
+					throw new InvalidOperationException(
+						"Unit `{0}` does not have a voxel `{1}`".F(unitName, voxelName));
+				else
+					throw new InvalidOperationException(
+						"Unit `{0}` does not have any voxels defined.".F(unitName));
+			}
+		}
+
+		public static bool HasVoxel(string unit, string seq)
+		{
+			if (!units.ContainsKey(unit))
+				throw new InvalidOperationException(
+					"Unit `{0}` does not have any voxels defined.".F(unit));
+
+			return units[unit].ContainsKey(seq);
+		}
+	}
+}

OpenRA.Game/Graphics/VoxelRenderable.cs

@@ -0,0 +1,106 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 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;
+
+namespace OpenRA.Graphics
+{
+	public struct VoxelRenderable : IRenderable
+	{
+		readonly IEnumerable<VoxelAnimation> voxels;
+		readonly WPos pos;
+		readonly int zOffset;
+		readonly WRot camera;
+		readonly WRot lightSource;
+		readonly float[] lightAmbientColor;
+		readonly float[] lightDiffuseColor;
+		readonly PaletteReference palette;
+		readonly PaletteReference normalsPalette;
+		readonly PaletteReference shadowPalette;
+		readonly float scale;
+
+		public VoxelRenderable(IEnumerable<VoxelAnimation> voxels, WPos pos, int zOffset, WRot camera, float scale,
+		                       WRot lightSource, float[] lightAmbientColor, float[] lightDiffuseColor,
+		                       PaletteReference color, PaletteReference normals, PaletteReference shadow)
+		{
+			this.voxels = voxels;
+			this.pos = pos;
+			this.zOffset = zOffset;
+			this.scale = scale;
+			this.camera = camera;
+			this.lightSource = lightSource;
+			this.lightAmbientColor = lightAmbientColor;
+			this.lightDiffuseColor = lightDiffuseColor;
+			this.palette = color;
+			this.normalsPalette = normals;
+			this.shadowPalette = shadow;
+		}
+
+		public WPos Pos { get { return pos; } }
+		public float Scale { get { return scale; } }
+		public PaletteReference Palette { get { return palette; } }
+		public int ZOffset { get { return zOffset; } }
+
+		public IRenderable WithScale(float newScale)
+		{
+			return new VoxelRenderable(voxels, pos, zOffset, camera, newScale,
+			                           lightSource, lightAmbientColor, lightDiffuseColor,
+			                           palette, normalsPalette, shadowPalette);
+		}
+
+		public IRenderable WithPalette(PaletteReference newPalette)
+		{
+			return new VoxelRenderable(voxels, pos, zOffset, camera, scale,
+			                           lightSource, lightAmbientColor, lightDiffuseColor,
+			                           newPalette, normalsPalette, shadowPalette);
+		}
+
+		public IRenderable WithZOffset(int newOffset)
+		{
+			return new VoxelRenderable(voxels, pos, newOffset, camera, scale,
+			                           lightSource, lightAmbientColor, lightDiffuseColor,
+			                           palette, normalsPalette, shadowPalette);
+		}
+
+		public IRenderable WithPos(WPos newPos)
+		{
+			return new VoxelRenderable(voxels, newPos, zOffset, camera, scale,
+			                           lightSource, lightAmbientColor, lightDiffuseColor,
+			                           palette, normalsPalette, shadowPalette);
+		}
+
+		public void Render(WorldRenderer wr)
+		{
+			// Depth and shadow buffers are cleared between actors so that
+			// overlapping units and shadows behave like overlapping sprites.
+			var vr = Game.Renderer.WorldVoxelRenderer;
+			var draw = voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
+
+			foreach (var v in draw)
+				v.Voxel.PrepareForDraw(wr, pos + v.OffsetFunc(), v.RotationFunc(), camera,
+				                       v.FrameFunc(), scale, lightSource);
+
+			Game.Renderer.EnableDepthBuffer();
+			Game.Renderer.EnableStencilBuffer();
+			foreach (var v in draw)
+				v.Voxel.DrawShadow(vr, shadowPalette.Index);
+			Game.Renderer.DisableStencilBuffer();
+			Game.Renderer.DisableDepthBuffer();
+
+			Game.Renderer.EnableDepthBuffer();
+			foreach (var v in draw)
+				v.Voxel.Draw(vr, lightAmbientColor, lightDiffuseColor, palette.Index, normalsPalette.Index);
+			Game.Renderer.DisableDepthBuffer();
+		}
+	}
+}

OpenRA.Game/Graphics/VoxelRenderer.cs

@@ -0,0 +1,88 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 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.FileFormats;
+using OpenRA.FileFormats.Graphics;
+
+namespace OpenRA.Graphics
+{
+	public class VoxelRenderer
+	{
+		Renderer renderer;
+		IShader shader;
+		IShader shadowShader;
+
+		public VoxelRenderer(Renderer renderer, IShader shader, IShader shadowShader)
+		{
+			this.renderer = renderer;
+			this.shader = shader;
+			this.shadowShader = shadowShader;
+		}
+
+		public void Render(VoxelLoader loader, VoxelRenderData renderData,
+		                   float[] t, float[] lightDirection,
+		                   float[] ambientLight, float[] diffuseLight,
+		                   int colorPalette, int normalsPalette)
+		{
+			shader.SetTexture("DiffuseTexture", renderData.Sheet.Texture);
+			shader.SetVec("PaletteRows", (colorPalette + 0.5f) / HardwarePalette.MaxPalettes,
+			                             (normalsPalette + 0.5f) / HardwarePalette.MaxPalettes);
+			shader.SetMatrix("TransformMatrix", t);
+			shader.SetVec("LightDirection", lightDirection, 4);
+			shader.SetVec("AmbientLight", ambientLight, 3);
+			shader.SetVec("DiffuseLight", diffuseLight, 3);
+			shader.Render(() => renderer.DrawBatch(loader.VertexBuffer, renderData.Start, renderData.Count, PrimitiveType.QuadList));
+		}
+
+		public void RenderShadow(VoxelLoader loader, VoxelRenderData renderData,
+		                   float[] t, float[] lightDirection, float[] groundNormal, float groundZ, int colorPalette)
+		{
+			shadowShader.SetTexture("DiffuseTexture", renderData.Sheet.Texture);
+			shadowShader.SetVec("PaletteRows", (colorPalette + 0.5f) / HardwarePalette.MaxPalettes, 0);
+			shadowShader.SetMatrix("TransformMatrix", t);
+			shadowShader.SetVec("LightDirection", lightDirection, 4);
+			shadowShader.SetVec("GroundNormal", groundNormal, 3);
+			shadowShader.SetVec("GroundZ", groundZ);
+			shadowShader.Render(() => renderer.DrawBatch(loader.VertexBuffer, renderData.Start, renderData.Count, PrimitiveType.QuadList));
+		}
+
+		public void SetPalette(ITexture palette)
+		{
+			shader.SetTexture("Palette", palette);
+			shadowShader.SetTexture("Palette", palette);
+		}
+
+		public void SetViewportParams(Size screen, float zoom, float2 scroll)
+		{
+			// Construct projection matrix
+			// Clip planes are set at -height and +2*height
+
+			var tiw = 2*zoom / screen.Width;
+			var tih = 2*zoom / screen.Height;
+			var view = new float[]
+			{
+				tiw, 0, 0, 0,
+				0, -tih, 0, 0,
+				0, 0, -tih/3, 0,
+				-1 - tiw*scroll.X,
+				1 + tih*scroll.Y,
+				1 + tih*scroll.Y/3,
+				1
+			};
+
+			shader.SetMatrix("View", view);
+			shadowShader.SetMatrix("View", view);
+		}
+	}
+}

OpenRA.Game/Map.cs

@@ -59,6 +59,7 @@ namespace OpenRA
 
 		[FieldLoader.Ignore] public List<MiniYamlNode> Rules = new List<MiniYamlNode>();
 		[FieldLoader.Ignore] public List<MiniYamlNode> Sequences = new List<MiniYamlNode>();
+		[FieldLoader.Ignore] public List<MiniYamlNode> VoxelSequences = new List<MiniYamlNode>();
 		[FieldLoader.Ignore] public List<MiniYamlNode> Weapons = new List<MiniYamlNode>();
 		[FieldLoader.Ignore] public List<MiniYamlNode> Voices = new List<MiniYamlNode>();
 		[FieldLoader.Ignore] public List<MiniYamlNode> Notifications = new List<MiniYamlNode>();
@@ -150,6 +151,7 @@ namespace OpenRA
 
 			Rules = NodesOrEmpty(yaml, "Rules");
 			Sequences = NodesOrEmpty(yaml, "Sequences");
+			VoxelSequences = NodesOrEmpty(yaml, "VoxelSequences");
 			Weapons = NodesOrEmpty(yaml, "Weapons");
 			Voices = NodesOrEmpty(yaml, "Voices");
 			Notifications = NodesOrEmpty(yaml, "Notifications");
@@ -206,6 +208,7 @@ namespace OpenRA
 			root.Add(new MiniYamlNode("Smudges", MiniYaml.FromList<SmudgeReference>( Smudges.Value )));
 			root.Add(new MiniYamlNode("Rules", null, Rules));
 			root.Add(new MiniYamlNode("Sequences", null, Sequences));
+			root.Add(new MiniYamlNode("VoxelSequences", null, VoxelSequences));
 			root.Add(new MiniYamlNode("Weapons", null, Weapons));
 			root.Add(new MiniYamlNode("Voices", null, Voices));
 			root.Add(new MiniYamlNode("Notifications", null, Notifications));

OpenRA.Game/ModData.cs

@@ -28,6 +28,7 @@ namespace OpenRA
 		public ILoadScreen LoadScreen = null;
 		public SheetBuilder SheetBuilder;
 		public SpriteLoader SpriteLoader;
+		public VoxelLoader VoxelLoader;
 
 		public ModData(params string[] mods)
 		{
@@ -55,6 +56,7 @@ namespace OpenRA
 			ChromeProvider.Initialize(Manifest.Chrome);
 			SheetBuilder = new SheetBuilder(SheetType.Indexed);
 			SpriteLoader = new SpriteLoader(new string[] { ".shp" }, SheetBuilder);
+			VoxelLoader = new VoxelLoader();
 			CursorProvider.Initialize(Manifest.Cursors);
 		}
 
@@ -76,7 +78,7 @@ namespace OpenRA
 			SpriteLoader = new SpriteLoader(Rules.TileSets[map.Tileset].Extensions, SheetBuilder);
 			// TODO: Don't load the sequences for assets that are not used in this tileset. Maybe use the existing EditorTilesetFilters.
 			SequenceProvider.Initialize(Manifest.Sequences, map.Sequences);
-
+			VoxelProvider.Initialize(Manifest.VoxelSequences, map.VoxelSequences);
 			return map;
 		}
 

OpenRA.Game/OpenRA.Game.csproj

@@ -226,7 +226,13 @@
     <Compile Include="Widgets\ClientTooltipRegionWidget.cs" />
     <Compile Include="Graphics\Renderable.cs" />
     <Compile Include="Traits\Render\RenderSprites.cs" />
+    <Compile Include="Graphics\Voxel.cs" />
+    <Compile Include="Graphics\VoxelRenderer.cs" />
+    <Compile Include="Graphics\VoxelLoader.cs" />
+    <Compile Include="Graphics\VoxelProvider.cs" />
     <Compile Include="Traits\BodyOrientation.cs" />
+    <Compile Include="Graphics\VoxelAnimation.cs" />
+    <Compile Include="Graphics\VoxelRenderable.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenRA.FileFormats\OpenRA.FileFormats.csproj">