Rename VoxelRenderable to ModelRenderable.

OpenRA.Mods.Common/Graphics/ModelRenderable.cs

@@ -18,9 +18,9 @@ using OpenRA.Primitives;
 
 namespace OpenRA.Mods.Common.Graphics
 {
-	public struct VoxelRenderable : IRenderable
+	public struct ModelRenderable : IRenderable
 	{
-		readonly IEnumerable<ModelAnimation> voxels;
+		readonly IEnumerable<ModelAnimation> models;
 		readonly WPos pos;
 		readonly int zOffset;
 		readonly WRot camera;
@@ -32,12 +32,12 @@ namespace OpenRA.Mods.Common.Graphics
 		readonly PaletteReference shadowPalette;
 		readonly float scale;
 
-		public VoxelRenderable(
+		public ModelRenderable(
-			IEnumerable<ModelAnimation> voxels, WPos pos, int zOffset, WRot camera, float scale,
+			IEnumerable<ModelAnimation> models, WPos pos, int zOffset, WRot camera, float scale,
 			WRot lightSource, float[] lightAmbientColor, float[] lightDiffuseColor,
 			PaletteReference color, PaletteReference normals, PaletteReference shadow)
 		{
-			this.voxels = voxels;
+			this.models = models;
 			this.pos = pos;
 			this.zOffset = zOffset;
 			this.scale = scale;
@@ -57,24 +57,24 @@ namespace OpenRA.Mods.Common.Graphics
 
 		public IRenderable WithPalette(PaletteReference newPalette)
 		{
-			return new VoxelRenderable(
+			return new ModelRenderable(
-				voxels, pos, zOffset, camera, scale,
+				models, pos, zOffset, camera, scale,
 				lightSource, lightAmbientColor, lightDiffuseColor,
 				newPalette, normalsPalette, shadowPalette);
 		}
 
 		public IRenderable WithZOffset(int newOffset)
 		{
-			return new VoxelRenderable(
+			return new ModelRenderable(
-				voxels, pos, newOffset, camera, scale,
+				models, pos, newOffset, camera, scale,
 				lightSource, lightAmbientColor, lightDiffuseColor,
 				palette, normalsPalette, shadowPalette);
 		}
 
 		public IRenderable OffsetBy(WVec vec)
 		{
-			return new VoxelRenderable(
+			return new ModelRenderable(
-				voxels, pos + vec, zOffset, camera, scale,
+				models, pos + vec, zOffset, camera, scale,
 				lightSource, lightAmbientColor, lightDiffuseColor,
 				palette, normalsPalette, shadowPalette);
 		}
@@ -85,32 +85,32 @@ namespace OpenRA.Mods.Common.Graphics
 		static readonly float[] GroundNormal = new float[] { 0, 0, 1, 1 };
 		public IFinalizedRenderable PrepareRender(WorldRenderer wr)
 		{
-			return new FinalizedVoxelRenderable(wr, this);
+			return new FinalizedModelRenderable(wr, this);
 		}
 
-		struct FinalizedVoxelRenderable : IFinalizedRenderable
+		struct FinalizedModelRenderable : IFinalizedRenderable
 		{
-			readonly VoxelRenderable voxel;
+			readonly ModelRenderable model;
 			readonly ModelRenderProxy renderProxy;
 
-			public FinalizedVoxelRenderable(WorldRenderer wr, VoxelRenderable voxel)
+			public FinalizedModelRenderable(WorldRenderer wr, ModelRenderable model)
 			{
-				this.voxel = voxel;
+				this.model = model;
-				var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
+				var draw = model.models.Where(v => v.DisableFunc == null || !v.DisableFunc());
 
 				renderProxy = Game.Renderer.WorldModelRenderer.RenderAsync(
-					wr, draw, voxel.camera, voxel.scale, GroundNormal, voxel.lightSource,
+					wr, draw, model.camera, model.scale, GroundNormal, model.lightSource,
-					voxel.lightAmbientColor, voxel.lightDiffuseColor,
+					model.lightAmbientColor, model.lightDiffuseColor,
-					voxel.palette, voxel.normalsPalette, voxel.shadowPalette);
+					model.palette, model.normalsPalette, model.shadowPalette);
 			}
 
 			public void Render(WorldRenderer wr)
 			{
-				var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length);
+				var groundPos = model.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(model.pos).Length);
 				var tileScale = wr.World.Map.Grid.Type == MapGridType.RectangularIsometric ? 1448f : 1024f;
 
-				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / tileScale;
+				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - model.pos.Z) / tileScale;
-				var pxOrigin = wr.Screen3DPosition(voxel.pos);
+				var pxOrigin = wr.Screen3DPosition(model.pos);
 
 				// HACK: We don't have enough texture channels to pass the depth data to the shader
 				// so for now just offset everything forward so that the back corner is rendered at pos.
@@ -129,9 +129,9 @@ namespace OpenRA.Mods.Common.Graphics
 
 			public void RenderDebugGeometry(WorldRenderer wr)
 			{
-				var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length);
+				var groundPos = model.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(model.pos).Length);
-				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / 1024f;
+				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - model.pos.Z) / 1024f;
-				var pxOrigin = wr.Screen3DPosition(voxel.pos);
+				var pxOrigin = wr.Screen3DPosition(model.pos);
 				var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1));
 				var iz = 1 / wr.Viewport.Zoom;
 
@@ -151,10 +151,10 @@ namespace OpenRA.Mods.Common.Graphics
 					shadowOrigin + psb[2]
 				}, iz, c);
 
-				// Draw voxel bounding box
+				// Draw bounding box
-				var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
+				var draw = model.models.Where(v => v.DisableFunc == null || !v.DisableFunc());
-				var scaleTransform = OpenRA.Graphics.Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale);
+				var scaleTransform = OpenRA.Graphics.Util.ScaleMatrix(model.scale, model.scale, model.scale);
-				var cameraTransform = OpenRA.Graphics.Util.MakeFloatMatrix(voxel.camera.AsMatrix());
+				var cameraTransform = OpenRA.Graphics.Util.MakeFloatMatrix(model.camera.AsMatrix());
 
 				foreach (var v in draw)
 				{
@@ -202,10 +202,10 @@ namespace OpenRA.Mods.Common.Graphics
 
 			Pair<Rectangle, float2> Screen3DBounds(WorldRenderer wr)
 			{
-				var pxOrigin = wr.ScreenPosition(voxel.pos);
+				var pxOrigin = wr.ScreenPosition(model.pos);
-				var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
+				var draw = model.models.Where(v => v.DisableFunc == null || !v.DisableFunc());
-				var scaleTransform = OpenRA.Graphics.Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale);
+				var scaleTransform = OpenRA.Graphics.Util.ScaleMatrix(model.scale, model.scale, model.scale);
-				var cameraTransform = OpenRA.Graphics.Util.MakeFloatMatrix(voxel.camera.AsMatrix());
+				var cameraTransform = OpenRA.Graphics.Util.MakeFloatMatrix(model.camera.AsMatrix());
 
 				var minX = float.MaxValue;
 				var minY = float.MaxValue;

OpenRA.Mods.Common/Graphics/VoxelActorPreview.cs

@@ -52,7 +52,7 @@ namespace OpenRA.Mods.Common.Graphics
 
 		public IEnumerable<IRenderable> Render(WorldRenderer wr, WPos pos)
 		{
-			yield return new VoxelRenderable(components, pos + offset, zOffset, camera, scale,
+			yield return new ModelRenderable(components, pos + offset, zOffset, camera, scale,
 				lightSource, lightAmbientColor, lightDiffuseColor,
 				colorPalette, normalsPalette, shadowPalette);
 		}

OpenRA.Mods.Common/OpenRA.Mods.Common.csproj

@@ -165,7 +165,7 @@
     <Compile Include="Graphics\SpriteActorPreview.cs" />
     <Compile Include="Graphics\TextRenderable.cs" />
     <Compile Include="Graphics\VoxelActorPreview.cs" />
-    <Compile Include="Graphics\VoxelRenderable.cs" />
+    <Compile Include="Graphics\ModelRenderable.cs" />
     <Compile Include="HitShapes\IHitShape.cs" />
     <Compile Include="HitShapes\Rectangle.cs" />
     <Compile Include="HitShapes\Capsule.cs" />

OpenRA.Mods.Common/Traits/Render/RenderVoxels.cs

@@ -102,7 +102,7 @@ namespace OpenRA.Mods.Common.Traits.Render
 				initializePalettes = false;
 			}
 
-			return new IRenderable[] { new VoxelRenderable(
+			return new IRenderable[] { new ModelRenderable(
 				components, self.CenterPosition, 0, camera, info.Scale,
 				lightSource, info.LightAmbientColor, info.LightDiffuseColor,
 				colorPalette, normalsPalette, shadowPalette) };