Use higher colour depth sprites in D2k.

OpenRA.Mods.D2k/Graphics/D2kSpriteSequence.cs

@@ -0,0 +1,206 @@
+#region Copyright & License Information
+/*
+ * Copyright (c) The OpenRA Developers and Contributors
+ * 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using OpenRA.Graphics;
+using OpenRA.Mods.Common.Graphics;
+using OpenRA.Mods.D2k.SpriteLoaders;
+using OpenRA.Primitives;
+
+namespace OpenRA.Mods.Cnc.Graphics
+{
+	public class D2kSpriteSequenceLoader : DefaultSpriteSequenceLoader
+	{
+		public D2kSpriteSequenceLoader(ModData modData)
+			: base(modData) { }
+
+		public override ISpriteSequence CreateSequence(ModData modData, string tileset, SpriteCache cache, string image, string sequence, MiniYaml data, MiniYaml defaults)
+		{
+			return new D2kSpriteSequence(cache, this, image, sequence, data, defaults);
+		}
+	}
+
+	[Desc("A sprite sequence that understands how to apply colour remapping to D2k sprites.")]
+	public class D2kSpriteSequence : DefaultSpriteSequence
+	{
+		[Desc("Sets the player remap reference colour.")]
+		static readonly SpriteSequenceField<Color> Remap = new(nameof(Remap), default);
+
+		[Desc("Remap embedded palette index 1 to shadow.")]
+		static readonly SpriteSequenceField<bool> UseShadow = new(nameof(UseShadow), true);
+
+		[Desc("Indicates that this is a fog sprite definition.")]
+		static readonly SpriteSequenceField<bool> ConvertShroudToFog = new(nameof(ConvertShroudToFog), false);
+
+		readonly Color remapColor;
+		readonly bool useShadow;
+		readonly bool convertShroudToFog;
+
+		public D2kSpriteSequence(SpriteCache cache, ISpriteSequenceLoader loader, string image, string sequence, MiniYaml data, MiniYaml defaults)
+			: base(cache, loader, image, sequence, data, defaults)
+		{
+			remapColor = LoadField(Remap, data, defaults);
+			useShadow = LoadField(UseShadow, data, defaults);
+			convertShroudToFog = LoadField(ConvertShroudToFog, data, defaults);
+		}
+
+		public override void ReserveSprites(ModData modData, string tileset, SpriteCache cache, MiniYaml data, MiniYaml defaults)
+		{
+			var frames = LoadField(Frames, data, defaults);
+			var flipX = LoadField(FlipX, data, defaults);
+			var flipY = LoadField(FlipY, data, defaults);
+			var zRamp = LoadField(ZRamp, data, defaults);
+			var offset = LoadField(Offset, data, defaults);
+			var blendMode = LoadField(BlendMode, data, defaults);
+
+			var combineNode = data.NodeWithKeyOrDefault(Combine.Key);
+			if (combineNode != null)
+			{
+				for (var i = 0; i < combineNode.Value.Nodes.Length; i++)
+				{
+					var subData = combineNode.Value.Nodes[i].Value;
+					var subOffset = LoadField(Offset, subData, NoData);
+					var subFlipX = LoadField(FlipX, subData, NoData);
+					var subFlipY = LoadField(FlipY, subData, NoData);
+					var subFrames = LoadField(Frames, subData);
+
+					foreach (var f in ParseCombineFilenames(modData, tileset, subFrames, subData))
+					{
+						int token;
+						if (remapColor != default || convertShroudToFog)
+							token = cache.ReserveFrames(f.Filename, f.LoadFrames, f.Location);
+						else
+							token = cache.ReserveSprites(f.Filename, f.LoadFrames, f.Location);
+
+						spritesToLoad.Add(new SpriteReservation
+						{
+							Token = token,
+							Offset = subOffset + offset,
+							FlipX = subFlipX ^ flipX,
+							FlipY = subFlipY ^ flipY,
+							BlendMode = blendMode,
+							ZRamp = zRamp,
+							Frames = f.Frames
+						});
+					}
+				}
+			}
+			else
+			{
+				foreach (var f in ParseFilenames(modData, tileset, frames, data, defaults))
+				{
+					int token;
+					if (remapColor != default || convertShroudToFog)
+						token = cache.ReserveFrames(f.Filename, f.LoadFrames, f.Location);
+					else
+						token = cache.ReserveSprites(f.Filename, f.LoadFrames, f.Location);
+
+					spritesToLoad.Add(new SpriteReservation
+					{
+						Token = token,
+						Offset = offset,
+						FlipX = flipX,
+						FlipY = flipY,
+						BlendMode = blendMode,
+						ZRamp = zRamp,
+						Frames = f.Frames,
+					});
+				}
+			}
+		}
+
+		public override void ResolveSprites(SpriteCache cache)
+		{
+			if (bounds != null)
+				return;
+
+			Sprite depthSprite = null;
+			if (depthSpriteReservation != null)
+				depthSprite = cache.ResolveSprites(depthSpriteReservation.Value).First(s => s != null);
+
+			var allSprites = spritesToLoad.SelectMany(r =>
+			{
+				Sprite[] resolved;
+				if (remapColor != default || convertShroudToFog)
+					resolved = cache.ResolveFrames(r.Token)
+						.Select(f => (f is R8Loader.RemappableFrame rf) ? rf.WithSequenceFlags(useShadow, convertShroudToFog, remapColor) : f)
+						.Select(f =>
+						{
+							if (f == null)
+								return null;
+
+							return cache.SheetBuilders[SheetBuilder.FrameTypeToSheetType(f.Type)]
+								.Add(f.Data, f.Type, f.Size, 0, f.Offset);
+						}).ToArray();
+				else
+					resolved = cache.ResolveSprites(r.Token);
+
+				if (r.Frames != null)
+					resolved = r.Frames.Select(f => resolved[f]).ToArray();
+
+				return resolved.Select(s =>
+				{
+					if (s == null)
+						return null;
+
+					var dx = r.Offset.X + (r.FlipX ? -s.Offset.X : s.Offset.X);
+					var dy = r.Offset.Y + (r.FlipY ? -s.Offset.Y : s.Offset.Y);
+					var dz = r.Offset.Z + s.Offset.Z + r.ZRamp * dy;
+					var sprite = new Sprite(s.Sheet, FlipRectangle(s.Bounds, r.FlipX, r.FlipY), r.ZRamp, new float3(dx, dy, dz), s.Channel, r.BlendMode);
+					if (depthSprite == null)
+						return sprite;
+
+					var cw = (depthSprite.Bounds.Left + depthSprite.Bounds.Right) / 2 + (int)(s.Offset.X + depthSpriteOffset.X);
+					var ch = (depthSprite.Bounds.Top + depthSprite.Bounds.Bottom) / 2 + (int)(s.Offset.Y + depthSpriteOffset.Y);
+					var w = s.Bounds.Width / 2;
+					var h = s.Bounds.Height / 2;
+
+					return new SpriteWithSecondaryData(sprite, depthSprite.Sheet, Rectangle.FromLTRB(cw - w, ch - h, cw + w, ch + h), depthSprite.Channel);
+				});
+			}).ToArray();
+
+			length ??= allSprites.Length - start;
+
+			if (alpha != null)
+			{
+				if (alpha.Length == 1)
+					alpha = Exts.MakeArray(length.Value, _ => alpha[0]);
+				else if (alpha.Length != length.Value)
+					throw new YamlException($"Sequence {image}.{Name} must define either 1 or {length.Value} Alpha values.");
+			}
+			else if (alphaFade)
+				alpha = Exts.MakeArray(length.Value, i => float2.Lerp(1f, 0f, i / (length.Value - 1f)));
+
+			// Reindex sprites to order facings anti-clockwise and remove unused frames
+			var index = CalculateFrameIndices(start, length.Value, stride ?? length.Value, facings, null, transpose, reverseFacings, -1);
+			if (reverses)
+			{
+				index.AddRange(index.Skip(1).Take(length.Value - 2).Reverse());
+				length = 2 * length - 2;
+			}
+
+			if (index.Count == 0)
+				throw new YamlException($"Sequence {image}.{Name} does not define any frames.");
+
+			var minIndex = index.Min();
+			var maxIndex = index.Max();
+			if (minIndex < 0 || maxIndex >= allSprites.Length)
+				throw new YamlException($"Sequence {image}.{Name} uses frames between {minIndex}..{maxIndex}, but only 0..{allSprites.Length - 1} exist.");
+
+			sprites = index.Select(f => allSprites[f]).ToArray();
+			if (shadowStart >= 0)
+				shadowSprites = index.Select(f => allSprites[f - start + shadowStart]).ToArray();
+
+			bounds = sprites.Concat(shadowSprites ?? Enumerable.Empty<Sprite>()).Select(OffsetSpriteBounds).Union();
+		}
+	}
+}

OpenRA.Mods.D2k/SpriteLoaders/R8Loader.cs

@@ -9,28 +9,104 @@
  */
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using OpenRA.Graphics;
-using OpenRA.Mods.Common.SpriteLoaders;
 using OpenRA.Primitives;
 
 namespace OpenRA.Mods.D2k.SpriteLoaders
 {
 	public class R8Loader : ISpriteLoader
 	{
-		sealed class R8Frame : ISpriteFrame
+		public sealed class RemappableFrame : ISpriteFrame
 		{
-			public SpriteFrameType Type => SpriteFrameType.Indexed8;
+			public SpriteFrameType Type => SpriteFrameType.Bgra32;
+			public Size Size => inner.Size;
+			public Size FrameSize => inner.FrameSize;
+			public float2 Offset => inner.Offset;
+			public bool DisableExportPadding => inner.DisableExportPadding;
+
+			readonly Frame inner;
+			readonly bool useShadow;
+			readonly bool convertShroudToFog;
+			readonly Color remap;
+			byte[] data;
+
+			public RemappableFrame(Frame inner, bool useShadow = true, bool convertShroudToFog = false, Color remap = default)
+			{
+				this.inner = inner;
+				this.useShadow = useShadow;
+				this.convertShroudToFog = convertShroudToFog;
+				this.remap = remap;
+			}
+
+			public byte[] Data
+			{
+				get
+				{
+					if (data == null)
+					{
+						var pixelCount = inner.Size.Width * inner.Size.Height;
+						data = new byte[4 * pixelCount];
+
+						var palette = inner.Palette;
+						if (useShadow || convertShroudToFog || remap != default)
+						{
+							palette = new uint[256];
+							Array.Copy(inner.Palette, palette, 256);
+						}
+
+						// Bit twiddling is equivalent to unpacking RGB channels, dividing them by 2, subtracting from 255, then repacking
+						if (convertShroudToFog)
+							for (var i = 0; i < Palette.Size; i++)
+								palette[i] = ~((palette[i] >> 1) & 0x007F7F7F);
+
+						// Remap index 1 to shadow
+						if (useShadow)
+							palette[1] = 140u << 24;
+
+						if (remap != default)
+						{
+							var r = new PlayerColorRemap(Enumerable.Range(240, 16).ToArray(), remap);
+							for (var i = 240; i < 256; i++)
+								palette[i] = (uint)r.GetRemappedColor(Color.FromArgb(palette[i]), i).ToArgb();
+						}
+
+						unsafe
+						{
+							fixed (byte* bd = &Data[0])
+							{
+								var data = (uint*)bd;
+								for (var i = 0; i < pixelCount; i++)
+									data[i] = palette[inner.Data[i]];
+							}
+						}
+					}
+
+					return data;
+				}
+			}
+
+			public RemappableFrame WithSequenceFlags(bool useShadow, bool convertShroudToFog, Color remap)
+			{
+				return new RemappableFrame(inner, useShadow, convertShroudToFog, remap);
+			}
+		}
+
+		public sealed class Frame : ISpriteFrame
+		{
+			public SpriteFrameType Type { get; }
 			public Size Size { get; }
 			public Size FrameSize { get; }
 			public float2 Offset { get; }
-			public byte[] Data { get; set; }
+			public byte[] Data { get; }
 			public bool DisableExportPadding => true;
 
-			public readonly uint[] Palette = null;
+			public uint[] Palette { get; }
 
-			public R8Frame(Stream s)
+			public Frame(Stream s, uint[] lastPalette)
 			{
 				// Scan forward until we find some data
 				var type = s.ReadUInt8();
@@ -45,11 +121,10 @@ namespace OpenRA.Mods.D2k.SpriteLoaders
 				Size = new Size(width, height);
 				Offset = new int2(width / 2 - x, height / 2 - y);
 
-				/*var imageOffset = */
-				s.ReadInt32();
-				var paletteOffset = s.ReadInt32();
+				s.ReadUInt32(); // imageHandle
+				var paletteHandle = s.ReadInt32();
 				var bpp = s.ReadUInt8();
-				if (bpp != 8)
+				if (bpp != 8 && bpp != 16)
 					throw new InvalidDataException($"Error: {bpp} bits per pixel are not supported.");
 
 				var frameHeight = s.ReadUInt8();
@@ -59,10 +134,32 @@ namespace OpenRA.Mods.D2k.SpriteLoaders
 				// Skip alignment byte
 				s.ReadUInt8();
 
-				Data = s.ReadBytes(width * height);
+				if (bpp == 16)
+				{
+					Data = new byte[width * height * 4];
+					Type = SpriteFrameType.Bgra32;
+
+					unsafe
+					{
+						fixed (byte* bd = &Data[0])
+						{
+							var data = (uint*)bd;
+							for (var i = 0; i < width * height; i++)
+							{
+								var packed = s.ReadUInt16();
+								data[i] = (uint)((0xFF << 24) | ((packed & 0x7C00) << 9) | ((packed & 0x3E0) << 6) | ((packed & 0x1f) << 3));
+							}
+						}
+					}
+				}
+				else
+				{
+					Data = s.ReadBytes(width * height);
+					Type = SpriteFrameType.Indexed8;
+				}
 
 				// Read palette
-				if (type == 1 && paletteOffset != 0)
+				if (type == 1 && paletteHandle != 0)
 				{
 					// Skip header
 					s.ReadUInt32();
@@ -72,9 +169,14 @@ namespace OpenRA.Mods.D2k.SpriteLoaders
 					for (var i = 0; i < 256; i++)
 					{
 						var packed = s.ReadUInt16();
-						Palette[i] = (uint)((255 << 24) | ((packed & 0xF800) << 8) | ((packed & 0x7E0) << 5) | ((packed & 0x1f) << 3));
+						Palette[i] = (uint)((0xFF << 24) | ((packed & 0x7C00) << 9) | ((packed & 0x3E0) << 6) | ((packed & 0x1f) << 3));
 					}
+
+					// Remap index 0 to transparent
+					Palette[0] = 0;
 				}
+				else if (type == 2)
+					Palette = lastPalette;
 			}
 		}
 
@@ -94,7 +196,7 @@ namespace OpenRA.Mods.D2k.SpriteLoaders
 			var d = s.ReadUInt8();
 
 			s.Position = start;
-			return d == 8;
+			return d == 8 || d == 16;
 		}
 
 		public bool TryParseSprite(Stream s, string filename, out ISpriteFrame[] frames, out TypeDictionary metadata)
@@ -107,21 +209,20 @@ namespace OpenRA.Mods.D2k.SpriteLoaders
 			}
 
 			var start = s.Position;
-			var tmp = new List<R8Frame>();
-			var palettes = new Dictionary<int, uint[]>();
+			var tmp = new List<Frame>();
+
+			uint[] lastPalette = null;
 			while (s.Position < s.Length)
 			{
-				var f = new R8Frame(s);
+				var f = new Frame(s, lastPalette);
 				if (f.Palette != null)
-					palettes.Add(tmp.Count, f.Palette);
+					lastPalette = f.Palette;
+
 				tmp.Add(f);
 			}
 
 			s.Position = start;
-
-			frames = tmp.ToArray();
-			if (palettes.Count > 0)
-				metadata = new TypeDictionary { new EmbeddedSpritePalette(framePalettes: palettes) };
+			frames = tmp.Select<Frame, ISpriteFrame>(f => f.Palette != null ? new RemappableFrame(f) : f).ToArray();
 
 			return true;
 		}