Lossless conversion tests

AssetRipper.TextureDecoder.TestGenerator/GenerationData.cs

@@ -1,18 +1,125 @@
-using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.Attributes;
+using AssetRipper.TextureDecoder.Rgb;
+using System.Reflection;
 
-namespace AssetRipper.TextureDecoder.TestGenerator
+namespace AssetRipper.TextureDecoder.TestGenerator
 {
-	internal struct GenerationData
+	internal readonly struct GenerationData
 	{
-		public Type ColorType;
-		public Type ChannelType;
-		public int ColorSize;
+		public Type ColorType { get; }
+		public Type ChannelType { get; }
+		public int ColorSize { get; }
+
+		public bool RedChannel { get; }
+		public bool GreenChannel { get; }
+		public bool BlueChannel { get; }
+		public bool AlphaChannel { get; }
+		public bool FullyUtilizedChannels { get; }
+
+		public bool IsFloatingPoint
+		{
+			get
+			{
+				return ChannelType == typeof(Half) || ChannelType == typeof(float) || ChannelType == typeof(double);
+			}
+		}
+
+		public int BitSizePerChannel
+		{
+			get
+			{
+				if (ChannelType == typeof(byte) || ChannelType == typeof(sbyte))
+				{
+					return 8;
+				}
+				else if (ChannelType == typeof(ushort) || ChannelType == typeof(short) || ChannelType == typeof(Half))
+				{
+					return 16;
+				}
+				else if (ChannelType == typeof(float))
+				{
+					return 32;
+				}
+				else if (ChannelType == typeof(double))
+				{
+					return 64;
+				}
+				else
+				{
+					throw new NotSupportedException(ChannelType.Name);
+				}
+			}
+		}
+
+		public string ChannelTypeName
+		{
+			get
+			{
+				return ChannelType.Name switch
+				{
+					"Byte" => "byte",
+					"SByte" => "sbyte",
+					"UInt16" => "ushort",
+					"Int16" => "short",
+					"Single" => "float",
+					"Double" => "double",
+					_ => ChannelType.Name,
+				};
+			}
+		}
 
 		public GenerationData(Type colorType, int colorSize)
 		{
 			ColorType = colorType;
 			ChannelType = ColorType.GetInterfaces().Single(t => t.Name == $"{nameof(IColor<byte>)}`1").GenericTypeArguments[0];
 			ColorSize = colorSize;
+
+			RgbaAttribute attribute = colorType.GetCustomAttribute<RgbaAttribute>() ?? throw new NullReferenceException(colorType.Name);
+			RedChannel = attribute.RedChannel;
+			GreenChannel = attribute.GreenChannel;
+			BlueChannel = attribute.BlueChannel;
+			AlphaChannel = attribute.AlphaChannel;
+			FullyUtilizedChannels = attribute.FullyUtilizedChannels;
+		}
+
+		public bool Contains(GenerationData other)
+		{
+			if (!FullyUtilizedChannels)
+			{
+				return false;
+			}
+
+			if (!IsFloatingPoint && other.IsFloatingPoint)
+			{
+				return false;
+			}
+			
+			if (IsFloatingPoint && !other.IsFloatingPoint)
+			{
+				return false;
+			}
+
+			if (other.RedChannel && !RedChannel)
+			{
+				return false;
+			}
+
+			if (other.GreenChannel && !GreenChannel)
+			{
+				return false;
+			}
+
+			if (other.BlueChannel && !BlueChannel)
+			{
+				return false;
+			}
+
+			if (other.AlphaChannel && !AlphaChannel)
+			{
+				return false;
+			}
+
+			return BitSizePerChannel >= other.BitSizePerChannel;
 		}
 	}
 }

AssetRipper.TextureDecoder.TestGenerator/Program.cs

@@ -1,4 +1,5 @@
-using AssetRipper.TextureDecoder.Rgb.Formats;
+using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.CodeDom.Compiler;
 
 namespace AssetRipper.TextureDecoder.TestGenerator
@@ -59,7 +60,7 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 		static void Main()
 		{
 			Directory.CreateDirectory(OutputFolder);
-
+			
 			foreach (GenerationData data in dataList)
 			{
 				using MemoryStream memoryStream = new();
@@ -83,6 +84,15 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 				textWriter.WriteLine();
 				textWriter.WriteMakeRandomColor(data);
 
+				foreach (GenerationData otherData in dataList)
+				{
+					if (otherData.Contains(data))
+					{
+						textWriter.WriteLine();
+						textWriter.WriteLosslessConversionTest(data, otherData);
+					}
+				}
+
 				textWriter.Indent -= 1;
 				textWriter.WriteClassDefinitionClose();
 
@@ -99,6 +109,7 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 
 		private static void WriteNamespaceUsings(this IndentedTextWriter textWriter, GenerationData data)
 		{
+			textWriter.WriteLine($"using {typeof(ColorExtensions).Namespace};");
 			textWriter.WriteLine($"using {data.ColorType.Namespace};");
 			textWriter.WriteLine($"using {typeof(System.Runtime.CompilerServices.Unsafe).Namespace};");
 			textWriter.WriteLine();//An empty line after the usings
@@ -274,5 +285,24 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 			textWriter.Indent -= 1;
 			textWriter.WriteLine("}");
 		}
+
+		private static void WriteLosslessConversionTest(this IndentedTextWriter textWriter, GenerationData currentData, GenerationData containingData)
+		{
+			string currentName = currentData.ColorType.Name;
+			string containingName = containingData.ColorType.Name;
+
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine($"public void ConversionTo{containingName}IsLossless()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			textWriter.WriteLine($"{currentName} original = MakeRandomColor();");
+			textWriter.WriteLine($"{containingName} converted = original.{nameof(ColorExtensions.Convert)}<{currentName}, {currentData.ChannelTypeName}, {containingName}, {containingData.ChannelTypeName}>();");
+			textWriter.WriteLine($"{currentName} convertedBack = converted.{nameof(ColorExtensions.Convert)}<{containingName}, {containingData.ChannelTypeName}, {currentName}, {currentData.ChannelTypeName}>();");
+			textWriter.WriteLine("Assert.That(convertedBack, Is.EqualTo(original));");
+			
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
 	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorA8Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,67 @@ public partial class ColorA8Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorA8IsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorA8 converted = original.Convert<ColorA8, byte, ColorA8, byte>();
+		ColorA8 convertedBack = converted.Convert<ColorA8, byte, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorA8, byte, ColorARGB32, byte>();
+		ColorA8 convertedBack = converted.Convert<ColorARGB32, byte, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorA8, byte, ColorBGRA32, byte>();
+		ColorA8 convertedBack = converted.Convert<ColorBGRA32, byte, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorA8, byte, ColorRGBA32, byte>();
+		ColorA8 convertedBack = converted.Convert<ColorRGBA32, byte, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorA8, byte, ColorRGBA32Signed, sbyte>();
+		ColorA8 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorA8, byte, ColorRGBA64, ushort>();
+		ColorA8 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorA8 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorA8, byte, ColorRGBA64Signed, short>();
+		ColorA8 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorA8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorARGB16Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorARGB16, byte, ColorARGB32, byte>();
+		ColorARGB16 convertedBack = converted.Convert<ColorARGB32, byte, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorARGB16, byte, ColorBGRA32, byte>();
+		ColorARGB16 convertedBack = converted.Convert<ColorBGRA32, byte, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorARGB16, byte, ColorRGBA32, byte>();
+		ColorARGB16 convertedBack = converted.Convert<ColorRGBA32, byte, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorARGB16, byte, ColorRGBA32Signed, sbyte>();
+		ColorARGB16 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorARGB16, byte, ColorRGBA64, ushort>();
+		ColorARGB16 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorARGB16 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorARGB16, byte, ColorRGBA64Signed, short>();
+		ColorARGB16 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorARGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorARGB32Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorARGB32, byte, ColorARGB32, byte>();
+		ColorARGB32 convertedBack = converted.Convert<ColorARGB32, byte, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorARGB32, byte, ColorBGRA32, byte>();
+		ColorARGB32 convertedBack = converted.Convert<ColorBGRA32, byte, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorARGB32, byte, ColorRGBA32, byte>();
+		ColorARGB32 convertedBack = converted.Convert<ColorRGBA32, byte, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorARGB32, byte, ColorRGBA32Signed, sbyte>();
+		ColorARGB32 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorARGB32, byte, ColorRGBA64, ushort>();
+		ColorARGB32 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorARGB32 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorARGB32, byte, ColorRGBA64Signed, short>();
+		ColorARGB32 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorARGB32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorBGRA32Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorBGRA32Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorBGRA32, byte, ColorARGB32, byte>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorARGB32, byte, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorBGRA32, byte, ColorBGRA32, byte>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorBGRA32, byte, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorBGRA32, byte, ColorRGBA32, byte>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorRGBA32, byte, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorBGRA32, byte, ColorRGBA32Signed, sbyte>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorBGRA32, byte, ColorRGBA64, ushort>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorBGRA32 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorBGRA32, byte, ColorRGBA64Signed, short>();
+		ColorBGRA32 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorBGRA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorR16SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,76 @@ public partial class ColorR16SignedTests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorR16IsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorR16 converted = original.Convert<ColorR16Signed, short, ColorR16, ushort>();
+		ColorR16Signed convertedBack = converted.Convert<ColorR16, ushort, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16SignedIsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorR16Signed converted = original.Convert<ColorR16Signed, short, ColorR16Signed, short>();
+		ColorR16Signed convertedBack = converted.Convert<ColorR16Signed, short, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorR16Signed, short, ColorRG32, ushort>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRG32, ushort, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorR16Signed, short, ColorRG32Signed, short>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRG32Signed, short, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorR16Signed, short, ColorRGB48, ushort>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorR16Signed, short, ColorRGB48Signed, short>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorR16Signed, short, ColorRGBA64, ushort>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorR16Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorR16Signed, short, ColorRGBA64Signed, short>();
+		ColorR16Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorR16Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorR16Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,76 @@ public partial class ColorR16Tests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorR16IsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorR16 converted = original.Convert<ColorR16, ushort, ColorR16, ushort>();
+		ColorR16 convertedBack = converted.Convert<ColorR16, ushort, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16SignedIsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorR16Signed converted = original.Convert<ColorR16, ushort, ColorR16Signed, short>();
+		ColorR16 convertedBack = converted.Convert<ColorR16Signed, short, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorR16, ushort, ColorRG32, ushort>();
+		ColorR16 convertedBack = converted.Convert<ColorRG32, ushort, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorR16, ushort, ColorRG32Signed, short>();
+		ColorR16 convertedBack = converted.Convert<ColorRG32Signed, short, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorR16, ushort, ColorRGB48, ushort>();
+		ColorR16 convertedBack = converted.Convert<ColorRGB48, ushort, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorR16, ushort, ColorRGB48Signed, short>();
+		ColorR16 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorR16, ushort, ColorRGBA64, ushort>();
+		ColorR16 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorR16 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorR16, ushort, ColorRGBA64Signed, short>();
+		ColorR16 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorR16, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorR8SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,166 @@ public partial class ColorR8SignedTests
 			A = -0b01000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorR8Signed, sbyte, ColorARGB32, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorARGB32, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorR8Signed, sbyte, ColorBGRA32, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorBGRA32, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorR16 converted = original.Convert<ColorR8Signed, sbyte, ColorR16, ushort>();
+		ColorR8Signed convertedBack = converted.Convert<ColorR16, ushort, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorR16Signed converted = original.Convert<ColorR8Signed, sbyte, ColorR16Signed, short>();
+		ColorR8Signed convertedBack = converted.Convert<ColorR16Signed, short, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR8IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorR8 converted = original.Convert<ColorR8Signed, sbyte, ColorR8, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorR8, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR8SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorR8Signed converted = original.Convert<ColorR8Signed, sbyte, ColorR8Signed, sbyte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorR8Signed, sbyte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRG16 converted = original.Convert<ColorR8Signed, sbyte, ColorRG16, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRG16, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRG16Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRG16Signed, sbyte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRG16Signed, sbyte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorR8Signed, sbyte, ColorRG32, ushort>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRG32, ushort, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRG32Signed, short>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRG32Signed, short, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorR8Signed, sbyte, ColorRGB24, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGB24, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRGB24Signed, sbyte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorR8Signed, sbyte, ColorRGB48, ushort>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRGB48Signed, short>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorR8Signed, sbyte, ColorRGBA32, byte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGBA32, byte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRGBA32Signed, sbyte>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorR8Signed, sbyte, ColorRGBA64, ushort>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorR8Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorR8Signed, sbyte, ColorRGBA64Signed, short>();
+		ColorR8Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorR8Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorR8Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,166 @@ public partial class ColorR8Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorR8, byte, ColorARGB32, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorARGB32, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorR8, byte, ColorBGRA32, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorBGRA32, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorR16 converted = original.Convert<ColorR8, byte, ColorR16, ushort>();
+		ColorR8 convertedBack = converted.Convert<ColorR16, ushort, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR16SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorR16Signed converted = original.Convert<ColorR8, byte, ColorR16Signed, short>();
+		ColorR8 convertedBack = converted.Convert<ColorR16Signed, short, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR8IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorR8 converted = original.Convert<ColorR8, byte, ColorR8, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorR8, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorR8SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorR8Signed converted = original.Convert<ColorR8, byte, ColorR8Signed, sbyte>();
+		ColorR8 convertedBack = converted.Convert<ColorR8Signed, sbyte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRG16 converted = original.Convert<ColorR8, byte, ColorRG16, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorRG16, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRG16Signed converted = original.Convert<ColorR8, byte, ColorRG16Signed, sbyte>();
+		ColorR8 convertedBack = converted.Convert<ColorRG16Signed, sbyte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorR8, byte, ColorRG32, ushort>();
+		ColorR8 convertedBack = converted.Convert<ColorRG32, ushort, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorR8, byte, ColorRG32Signed, short>();
+		ColorR8 convertedBack = converted.Convert<ColorRG32Signed, short, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorR8, byte, ColorRGB24, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorRGB24, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorR8, byte, ColorRGB24Signed, sbyte>();
+		ColorR8 convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorR8, byte, ColorRGB48, ushort>();
+		ColorR8 convertedBack = converted.Convert<ColorRGB48, ushort, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorR8, byte, ColorRGB48Signed, short>();
+		ColorR8 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorR8, byte, ColorRGBA32, byte>();
+		ColorR8 convertedBack = converted.Convert<ColorRGBA32, byte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorR8, byte, ColorRGBA32Signed, sbyte>();
+		ColorR8 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorR8, byte, ColorRGBA64, ushort>();
+		ColorR8 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorR8 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorR8, byte, ColorRGBA64Signed, short>();
+		ColorR8 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorR8, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRG16SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,130 @@ public partial class ColorRG16SignedTests
 			A = -0b01000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRG16Signed, sbyte, ColorARGB32, byte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorARGB32, byte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRG16Signed, sbyte, ColorBGRA32, byte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorBGRA32, byte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRG16 converted = original.Convert<ColorRG16Signed, sbyte, ColorRG16, byte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRG16, byte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRG16Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRG16Signed, sbyte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRG16Signed, sbyte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorRG16Signed, sbyte, ColorRG32, ushort>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRG32, ushort, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRG32Signed, short>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRG32Signed, short, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorRG16Signed, sbyte, ColorRGB24, byte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGB24, byte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRGB24Signed, sbyte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRG16Signed, sbyte, ColorRGB48, ushort>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRGB48Signed, short>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRG16Signed, sbyte, ColorRGBA32, byte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGBA32, byte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRGBA32Signed, sbyte>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRG16Signed, sbyte, ColorRGBA64, ushort>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRG16Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRG16Signed, sbyte, ColorRGBA64Signed, short>();
+		ColorRG16Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRG16Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRG16Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,130 @@ public partial class ColorRG16Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRG16, byte, ColorARGB32, byte>();
+		ColorRG16 convertedBack = converted.Convert<ColorARGB32, byte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRG16, byte, ColorBGRA32, byte>();
+		ColorRG16 convertedBack = converted.Convert<ColorBGRA32, byte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRG16 converted = original.Convert<ColorRG16, byte, ColorRG16, byte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRG16, byte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG16SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRG16Signed converted = original.Convert<ColorRG16, byte, ColorRG16Signed, sbyte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRG16Signed, sbyte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorRG16, byte, ColorRG32, ushort>();
+		ColorRG16 convertedBack = converted.Convert<ColorRG32, ushort, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorRG16, byte, ColorRG32Signed, short>();
+		ColorRG16 convertedBack = converted.Convert<ColorRG32Signed, short, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorRG16, byte, ColorRGB24, byte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGB24, byte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorRG16, byte, ColorRGB24Signed, sbyte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRG16, byte, ColorRGB48, ushort>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGB48, ushort, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRG16, byte, ColorRGB48Signed, short>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRG16, byte, ColorRGBA32, byte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGBA32, byte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRG16, byte, ColorRGBA32Signed, sbyte>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRG16, byte, ColorRGBA64, ushort>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRG16 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRG16, byte, ColorRGBA64Signed, short>();
+		ColorRG16 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRG16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRG32SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRG32SignedTests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorRG32Signed, short, ColorRG32, ushort>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRG32, ushort, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorRG32Signed, short, ColorRG32Signed, short>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRG32Signed, short, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRG32Signed, short, ColorRGB48, ushort>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRG32Signed, short, ColorRGB48Signed, short>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRG32Signed, short, ColorRGBA64, ushort>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRG32Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRG32Signed, short, ColorRGBA64Signed, short>();
+		ColorRG32Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRG32Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRG32Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRG32Tests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRG32IsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRG32 converted = original.Convert<ColorRG32, ushort, ColorRG32, ushort>();
+		ColorRG32 convertedBack = converted.Convert<ColorRG32, ushort, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRG32SignedIsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRG32Signed converted = original.Convert<ColorRG32, ushort, ColorRG32Signed, short>();
+		ColorRG32 convertedBack = converted.Convert<ColorRG32Signed, short, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRG32, ushort, ColorRGB48, ushort>();
+		ColorRG32 convertedBack = converted.Convert<ColorRGB48, ushort, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRG32, ushort, ColorRGB48Signed, short>();
+		ColorRG32 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRG32, ushort, ColorRGBA64, ushort>();
+		ColorRG32 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRG32 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRG32, ushort, ColorRGBA64Signed, short>();
+		ColorRG32 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRG32, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,94 @@ public partial class ColorRGB16Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGB16, byte, ColorARGB32, byte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorARGB32, byte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGB16, byte, ColorBGRA32, byte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorRGB16, byte, ColorRGB24, byte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGB24, byte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorRGB16, byte, ColorRGB24Signed, sbyte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRGB16, byte, ColorRGB48, ushort>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGB48, ushort, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRGB16, byte, ColorRGB48Signed, short>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGB16, byte, ColorRGBA32, byte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGB16, byte, ColorRGBA32Signed, sbyte>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGB16, byte, ColorRGBA64, ushort>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGB16 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGB16, byte, ColorRGBA64Signed, short>();
+		ColorRGB16 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGB16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,94 @@ public partial class ColorRGB24SignedTests
 			A = -0b01000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGB24Signed, sbyte, ColorARGB32, byte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorARGB32, byte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGB24Signed, sbyte, ColorBGRA32, byte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGB24, byte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGB24, byte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGB24Signed, sbyte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGB48, ushort>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGB48Signed, short>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGBA32, byte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGBA32Signed, sbyte>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGBA64, ushort>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGB24Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGB24Signed, sbyte, ColorRGBA64Signed, short>();
+		ColorRGB24Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGB24Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,94 @@ public partial class ColorRGB24Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGB24, byte, ColorARGB32, byte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorARGB32, byte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGB24, byte, ColorBGRA32, byte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGB24 converted = original.Convert<ColorRGB24, byte, ColorRGB24, byte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGB24, byte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB24SignedIsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGB24Signed converted = original.Convert<ColorRGB24, byte, ColorRGB24Signed, sbyte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGB24Signed, sbyte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRGB24, byte, ColorRGB48, ushort>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGB48, ushort, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRGB24, byte, ColorRGB48Signed, short>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGB24, byte, ColorRGBA32, byte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGB24, byte, ColorRGBA32Signed, sbyte>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGB24, byte, ColorRGBA64, ushort>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGB24 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGB24, byte, ColorRGBA64Signed, short>();
+		ColorRGB24 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGB24, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,40 @@ public partial class ColorRGB48SignedTests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRGB48Signed original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRGB48Signed, short, ColorRGB48, ushort>();
+		ColorRGB48Signed convertedBack = converted.Convert<ColorRGB48, ushort, ColorRGB48Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRGB48Signed original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRGB48Signed, short, ColorRGB48Signed, short>();
+		ColorRGB48Signed convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRGB48Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGB48Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGB48Signed, short, ColorRGBA64, ushort>();
+		ColorRGB48Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGB48Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGB48Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGB48Signed, short, ColorRGBA64Signed, short>();
+		ColorRGB48Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGB48Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,40 @@ public partial class ColorRGB48Tests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGB48IsLossless()
+	{
+		ColorRGB48 original = MakeRandomColor();
+		ColorRGB48 converted = original.Convert<ColorRGB48, ushort, ColorRGB48, ushort>();
+		ColorRGB48 convertedBack = converted.Convert<ColorRGB48, ushort, ColorRGB48, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGB48SignedIsLossless()
+	{
+		ColorRGB48 original = MakeRandomColor();
+		ColorRGB48Signed converted = original.Convert<ColorRGB48, ushort, ColorRGB48Signed, short>();
+		ColorRGB48 convertedBack = converted.Convert<ColorRGB48Signed, short, ColorRGB48, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGB48 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGB48, ushort, ColorRGBA64, ushort>();
+		ColorRGB48 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGB48, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGB48 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGB48, ushort, ColorRGBA64Signed, short>();
+		ColorRGB48 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGB48, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRGBA16Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGBA16, byte, ColorARGB32, byte>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorARGB32, byte, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGBA16, byte, ColorBGRA32, byte>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGBA16, byte, ColorRGBA32, byte>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGBA16, byte, ColorRGBA32Signed, sbyte>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGBA16, byte, ColorRGBA64, ushort>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGBA16 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGBA16, byte, ColorRGBA64Signed, short>();
+		ColorRGBA16 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGBA16, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRGBA32SignedTests
 			A = -0b01000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGBA32Signed, sbyte, ColorARGB32, byte>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorARGB32, byte, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGBA32Signed, sbyte, ColorBGRA32, byte>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGBA32Signed, sbyte, ColorRGBA32, byte>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGBA32Signed, sbyte, ColorRGBA32Signed, sbyte>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGBA32Signed, sbyte, ColorRGBA64, ushort>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGBA32Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGBA32Signed, sbyte, ColorRGBA64Signed, short>();
+		ColorRGBA32Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGBA32Signed, sbyte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRGBA32Tests
 			A = 0b11000111,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorARGB32IsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorARGB32 converted = original.Convert<ColorRGBA32, byte, ColorARGB32, byte>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorARGB32, byte, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorBGRA32IsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorBGRA32 converted = original.Convert<ColorRGBA32, byte, ColorBGRA32, byte>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorBGRA32, byte, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32IsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorRGBA32 converted = original.Convert<ColorRGBA32, byte, ColorRGBA32, byte>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorRGBA32, byte, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA32SignedIsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorRGBA32Signed converted = original.Convert<ColorRGBA32, byte, ColorRGBA32Signed, sbyte>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorRGBA32Signed, sbyte, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGBA32, byte, ColorRGBA64, ushort>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGBA32 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGBA32, byte, ColorRGBA64Signed, short>();
+		ColorRGBA32 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGBA32, byte>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64SignedTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,22 @@ public partial class ColorRGBA64SignedTests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGBA64Signed original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGBA64Signed, short, ColorRGBA64, ushort>();
+		ColorRGBA64Signed convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGBA64Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGBA64Signed original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGBA64Signed, short, ColorRGBA64Signed, short>();
+		ColorRGBA64Signed convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGBA64Signed, short>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64Tests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,22 @@ public partial class ColorRGBA64Tests
 			A = 347,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBA64IsLossless()
+	{
+		ColorRGBA64 original = MakeRandomColor();
+		ColorRGBA64 converted = original.Convert<ColorRGBA64, ushort, ColorRGBA64, ushort>();
+		ColorRGBA64 convertedBack = converted.Convert<ColorRGBA64, ushort, ColorRGBA64, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBA64SignedIsLossless()
+	{
+		ColorRGBA64 original = MakeRandomColor();
+		ColorRGBA64Signed converted = original.Convert<ColorRGBA64, ushort, ColorRGBA64Signed, short>();
+		ColorRGBA64 convertedBack = converted.Convert<ColorRGBA64Signed, short, ColorRGBA64, ushort>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBAHalfTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,22 @@ public partial class ColorRGBAHalfTests
 			A = (Half)0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBAHalfIsLossless()
+	{
+		ColorRGBAHalf original = MakeRandomColor();
+		ColorRGBAHalf converted = original.Convert<ColorRGBAHalf, Half, ColorRGBAHalf, Half>();
+		ColorRGBAHalf convertedBack = converted.Convert<ColorRGBAHalf, Half, ColorRGBAHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGBAHalf original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGBAHalf, Half, ColorRGBASingle, float>();
+		ColorRGBAHalf convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGBAHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBASingleTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,13 @@ public partial class ColorRGBASingleTests
 			A = 0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGBASingle original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGBASingle, float, ColorRGBASingle, float>();
+		ColorRGBASingle convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGBASingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBHalfTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,40 @@ public partial class ColorRGBHalfTests
 			A = (Half)0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBAHalfIsLossless()
+	{
+		ColorRGBHalf original = MakeRandomColor();
+		ColorRGBAHalf converted = original.Convert<ColorRGBHalf, Half, ColorRGBAHalf, Half>();
+		ColorRGBHalf convertedBack = converted.Convert<ColorRGBAHalf, Half, ColorRGBHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGBHalf original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGBHalf, Half, ColorRGBASingle, float>();
+		ColorRGBHalf convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGBHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBHalfIsLossless()
+	{
+		ColorRGBHalf original = MakeRandomColor();
+		ColorRGBHalf converted = original.Convert<ColorRGBHalf, Half, ColorRGBHalf, Half>();
+		ColorRGBHalf convertedBack = converted.Convert<ColorRGBHalf, Half, ColorRGBHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRGBHalf original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRGBHalf, Half, ColorRGBSingle, float>();
+		ColorRGBHalf convertedBack = converted.Convert<ColorRGBSingle, float, ColorRGBHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBSingleTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,22 @@ public partial class ColorRGBSingleTests
 			A = 0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGBSingle original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGBSingle, float, ColorRGBASingle, float>();
+		ColorRGBSingle convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGBSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRGBSingle original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRGBSingle, float, ColorRGBSingle, float>();
+		ColorRGBSingle convertedBack = converted.Convert<ColorRGBSingle, float, ColorRGBSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGHalfTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,58 @@ public partial class ColorRGHalfTests
 			A = (Half)0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBAHalfIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGBAHalf converted = original.Convert<ColorRGHalf, Half, ColorRGBAHalf, Half>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGBAHalf, Half, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGHalf, Half, ColorRGBASingle, float>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBHalfIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGBHalf converted = original.Convert<ColorRGHalf, Half, ColorRGBHalf, Half>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGBHalf, Half, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRGHalf, Half, ColorRGBSingle, float>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGBSingle, float, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGHalfIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGHalf converted = original.Convert<ColorRGHalf, Half, ColorRGHalf, Half>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGHalf, Half, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGSingleIsLossless()
+	{
+		ColorRGHalf original = MakeRandomColor();
+		ColorRGSingle converted = original.Convert<ColorRGHalf, Half, ColorRGSingle, float>();
+		ColorRGHalf convertedBack = converted.Convert<ColorRGSingle, float, ColorRGHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRGSingleTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,31 @@ public partial class ColorRGSingleTests
 			A = 0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRGSingle original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRGSingle, float, ColorRGBASingle, float>();
+		ColorRGSingle convertedBack = converted.Convert<ColorRGBASingle, float, ColorRGSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRGSingle original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRGSingle, float, ColorRGBSingle, float>();
+		ColorRGSingle convertedBack = converted.Convert<ColorRGBSingle, float, ColorRGSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGSingleIsLossless()
+	{
+		ColorRGSingle original = MakeRandomColor();
+		ColorRGSingle converted = original.Convert<ColorRGSingle, float, ColorRGSingle, float>();
+		ColorRGSingle convertedBack = converted.Convert<ColorRGSingle, float, ColorRGSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRHalfTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,76 @@ public partial class ColorRHalfTests
 			A = (Half)0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBAHalfIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGBAHalf converted = original.Convert<ColorRHalf, Half, ColorRGBAHalf, Half>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGBAHalf, Half, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRHalf, Half, ColorRGBASingle, float>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGBASingle, float, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBHalfIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGBHalf converted = original.Convert<ColorRHalf, Half, ColorRGBHalf, Half>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGBHalf, Half, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRHalf, Half, ColorRGBSingle, float>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGBSingle, float, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGHalfIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGHalf converted = original.Convert<ColorRHalf, Half, ColorRGHalf, Half>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGHalf, Half, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGSingleIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRGSingle converted = original.Convert<ColorRHalf, Half, ColorRGSingle, float>();
+		ColorRHalf convertedBack = converted.Convert<ColorRGSingle, float, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRHalfIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRHalf converted = original.Convert<ColorRHalf, Half, ColorRHalf, Half>();
+		ColorRHalf convertedBack = converted.Convert<ColorRHalf, Half, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRSingleIsLossless()
+	{
+		ColorRHalf original = MakeRandomColor();
+		ColorRSingle converted = original.Convert<ColorRHalf, Half, ColorRSingle, float>();
+		ColorRHalf convertedBack = converted.Convert<ColorRSingle, float, ColorRHalf, Half>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder.Tests/Formats/ColorRSingleTests.g.cs

@@ -1,5 +1,6 @@
 //This code is source generated. Do not edit manually.
 
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -152,4 +153,40 @@ public partial class ColorRSingleTests
 			A = 0.897f,
 		};
 	}
+	
+	[Test]
+	public void ConversionToColorRGBASingleIsLossless()
+	{
+		ColorRSingle original = MakeRandomColor();
+		ColorRGBASingle converted = original.Convert<ColorRSingle, float, ColorRGBASingle, float>();
+		ColorRSingle convertedBack = converted.Convert<ColorRGBASingle, float, ColorRSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGBSingleIsLossless()
+	{
+		ColorRSingle original = MakeRandomColor();
+		ColorRGBSingle converted = original.Convert<ColorRSingle, float, ColorRGBSingle, float>();
+		ColorRSingle convertedBack = converted.Convert<ColorRGBSingle, float, ColorRSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRGSingleIsLossless()
+	{
+		ColorRSingle original = MakeRandomColor();
+		ColorRGSingle converted = original.Convert<ColorRSingle, float, ColorRGSingle, float>();
+		ColorRSingle convertedBack = converted.Convert<ColorRGSingle, float, ColorRSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
+	
+	[Test]
+	public void ConversionToColorRSingleIsLossless()
+	{
+		ColorRSingle original = MakeRandomColor();
+		ColorRSingle converted = original.Convert<ColorRSingle, float, ColorRSingle, float>();
+		ColorRSingle convertedBack = converted.Convert<ColorRSingle, float, ColorRSingle, float>();
+		Assert.That(convertedBack, Is.EqualTo(original));
+	}
 }

AssetRipper.TextureDecoder/Rgb/IColor.cs

@@ -42,7 +42,7 @@
 		void SetChannels(T r, T g, T b, T a);
 	}
 
-	internal static class ColorExtensions
+	public static class ColorExtensions
 	{
 		[MethodImpl(OptimizationConstants.AggressiveInliningAndOptimization)]
 		internal static void SetConvertedChannels<TThis, TThisArg, TSourceArg>(this ref TThis color, TSourceArg r, TSourceArg g, TSourceArg b, TSourceArg a)
@@ -58,7 +58,7 @@
 		}
 
 		[MethodImpl(OptimizationConstants.AggressiveInliningAndOptimization)]
-		internal static TTarget Convert<TThis, TThisArg, TTarget, TTargetArg>(this TThis color)
+		public static TTarget Convert<TThis, TThisArg, TTarget, TTargetArg>(this TThis color)
 			where TThisArg : unmanaged
 			where TTargetArg : unmanaged
 			where TThis : unmanaged, IColor<TThisArg>