diff --git a/AssetRipper.TextureDecoder.ColorGenerator/AssetRipper.TextureDecoder.ColorGenerator.csproj b/AssetRipper.TextureDecoder.ColorGenerator/AssetRipper.TextureDecoder.ColorGenerator.csproj
index 00eab3e..47d0b3d 100644
--- a/AssetRipper.TextureDecoder.ColorGenerator/AssetRipper.TextureDecoder.ColorGenerator.csproj
+++ b/AssetRipper.TextureDecoder.ColorGenerator/AssetRipper.TextureDecoder.ColorGenerator.csproj
@@ -11,4 +11,8 @@
 		<PackageReference Include="AssetRipper.Text.SourceGeneration" Version="1.0.0" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <ProjectReference Include="..\AssetRipper.TextureDecoder.SourceGeneration.Common\AssetRipper.TextureDecoder.SourceGeneration.Common.csproj" />
+	</ItemGroup>
+
 </Project>
diff --git a/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs b/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
index bfa00bb..6c39e5f 100644
--- a/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
+++ b/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
@@ -1,4 +1,5 @@
 using AssetRipper.Text.SourceGeneration;
+using AssetRipper.TextureDecoder.SourceGeneration.Common;
 using System.CodeDom.Compiler;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -108,7 +109,7 @@ internal static class NumericConversionGenerator
 		writer.WriteLine($"private static TTo {methodName}<TTo>({fromName} value) where TTo : unmanaged");
 		using (new CurlyBrackets(writer))
 		{
-			if (IsSignedInteger(from, out Type? unsignedFrom))
+			if (CSharpPrimitives.IsSignedInteger(from, out Type? unsignedFrom))
 			{
 				writer.WriteLine($"{CSharpPrimitives.TypeNames[unsignedFrom]} unsigned = {ChangeSign}(value);");
 				writer.WriteLine($"return {ConvertMethodName(unsignedFrom)}<TTo>(unsigned);");
@@ -125,22 +126,22 @@ internal static class NumericConversionGenerator
 						{
 							writer.WriteLine($"return Unsafe.As<{toName}, TTo>(ref value);");
 						}
-						else if (IsSignedInteger(to, out Type? unsignedTo))
+						else if (CSharpPrimitives.IsSignedInteger(to, out Type? unsignedTo))
 						{
 							string unsignedToName = CSharpPrimitives.TypeNames[unsignedTo];
 							writer.WriteLine($"{toName} converted = {ChangeSign}({methodName}<{unsignedToName}>(value));");
 							writer.WriteLine($"return Unsafe.As<{toName}, TTo>(ref converted);");
 						}
-						else if (IsFloatingPoint(from))
+						else if (CSharpPrimitives.IsFloatingPoint(from))
 						{
-							if (IsFloatingPoint(to))
+							if (CSharpPrimitives.IsFloatingPoint(to))
 							{
 								writer.WriteLine($"{toName} converted = ({toName})value;");
 								writer.WriteLine($"return Unsafe.As<{toName}, TTo>(ref converted);");
 							}
 							else
 							{
-								Debug.Assert(IsUnsignedInteger(to));
+								Debug.Assert(CSharpPrimitives.IsUnsignedInteger(to));
 								if (from == typeof(Half))
 								{
 									writer.WriteComment("We use float because it has enough precision to convert from Half to any integer type.");
@@ -159,8 +160,8 @@ internal static class NumericConversionGenerator
 						}
 						else
 						{
-							Debug.Assert(IsUnsignedInteger(from));
-							if (IsFloatingPoint(to))
+							Debug.Assert(CSharpPrimitives.IsUnsignedInteger(from));
+							if (CSharpPrimitives.IsFloatingPoint(to))
 							{
 								if (to == typeof(Half))
 								{
@@ -178,7 +179,7 @@ internal static class NumericConversionGenerator
 							}
 							else
 							{
-								Debug.Assert(IsUnsignedInteger(to));
+								Debug.Assert(CSharpPrimitives.IsUnsignedInteger(to));
 								writer.WriteComment("See https://github.com/AssetRipper/TextureDecoder/issues/19");
 								int fromSize = CSharpPrimitives.Sizes[from];
 								int toSize = CSharpPrimitives.Sizes[to];
@@ -214,8 +215,8 @@ internal static class NumericConversionGenerator
 										string conversionType = fromSize <= sizeof(uint) ? "uint" : "ulong";
 										writer.WriteLine("unchecked");
 										using (new CurlyBrackets(writer))
-										{
-											int offset = (fromSize / toSize - 1) * toSize * 8;
+										{
+											int offset = (fromSize / toSize - 1) * toSize * 8;
 											writer.WriteLine($"{toName} converted = ({toName})(({conversionType})value >> {offset});");
 											writer.WriteLine($"return Unsafe.As<{toName}, TTo>(ref converted);");
 										}
@@ -239,39 +240,4 @@ internal static class NumericConversionGenerator
 	{
 		return $"Convert{from.Name}";
 	}
-
-	private static bool IsFloatingPoint(Type type)
-	{
-		return type == typeof(Half) || type == typeof(float) || type == typeof(double) || type == typeof(decimal);
-	}
-
-	private static bool IsSignedInteger(Type type, [NotNullWhen(true)] out Type? unsignedType)
-	{
-		if (type == typeof(sbyte))
-		{
-			unsignedType = typeof(byte);
-		}
-		else if (type == typeof(short))
-		{
-			unsignedType = typeof(ushort);
-		}
-		else if (type == typeof(int))
-		{
-			unsignedType = typeof(uint);
-		}
-		else if (type == typeof(long))
-		{
-			unsignedType = typeof(ulong);
-		}
-		else
-		{
-			unsignedType = null;
-		}
-		return unsignedType is not null;
-	}
-
-	private static bool IsUnsignedInteger(Type type)
-	{
-		return type == typeof(byte) || type == typeof(ushort) || type == typeof(uint) || type == typeof(ulong);
-	}
 }
diff --git a/AssetRipper.TextureDecoder.ColorGenerator/Program.cs b/AssetRipper.TextureDecoder.ColorGenerator/Program.cs
index 1868877..162425e 100644
--- a/AssetRipper.TextureDecoder.ColorGenerator/Program.cs
+++ b/AssetRipper.TextureDecoder.ColorGenerator/Program.cs
@@ -1,60 +1,20 @@
-using System.CodeDom.Compiler;
-
+using AssetRipper.Text.SourceGeneration;
+using AssetRipper.TextureDecoder.SourceGeneration.Common;
+using System.CodeDom.Compiler;
+using System.Text;
+
 namespace AssetRipper.TextureDecoder.ColorGenerator;
 
-internal static class Program
+internal static partial class Program
 {
 	private const string AttributeNamespace = "AssetRipper.TextureDecoder.Attributes";
 	private const string OutputNamespace = "AssetRipper.TextureDecoder.Rgb.Formats";
 	private const string OutputFolder = "../../../../AssetRipper.TextureDecoder/Rgb/Formats/";
 
-	/// <summary>
-	/// Name, Type, Red, Blue, Green, Alpha
-	/// </summary>
-	private static readonly List<(string, Type, bool, bool, bool, bool)> Colors = new()
-	{
-		( "ColorA8", typeof(byte), false, false, false, true ),
-
-		( "ColorR8", typeof(byte), true, false, false, false ),
-		( "ColorRG16", typeof(byte), true, true, false, false ),
-		( "ColorRGB24", typeof(byte), true, true, true, false ),
-		( "ColorRGBA32", typeof(byte), true, true, true, true ),
-
-		( "ColorR8Signed", typeof(sbyte), true, false, false, false ),
-		( "ColorRG16Signed", typeof(sbyte), true, true, false, false ),
-		( "ColorRGB24Signed", typeof(sbyte), true, true, true, false ),
-		( "ColorRGBA32Signed", typeof(sbyte), true, true, true, true ),
-
-		( "ColorR16", typeof(ushort), true, false, false, false ),
-		( "ColorRG32", typeof(ushort), true, true, false, false ),
-		( "ColorRGB48", typeof(ushort), true, true, true, false ),
-		( "ColorRGBA64", typeof(ushort), true, true, true, true ),
-
-		( "ColorR16Signed", typeof(short), true, false, false, false ),
-		( "ColorRG32Signed", typeof(short), true, true, false, false ),
-		( "ColorRGB48Signed", typeof(short), true, true, true, false ),
-		( "ColorRGBA64Signed", typeof(short), true, true, true, true ),
-
-		( "ColorR16Half", typeof(Half), true, false, false, false ),
-		( "ColorRG32Half", typeof(Half), true, true, false, false ),
-		( "ColorRGB48Half", typeof(Half), true, true, true, false ),
-		( "ColorRGBA64Half", typeof(Half), true, true, true, true ),
-
-		( "ColorR32Single", typeof(float), true, false, false, false ),
-		( "ColorRG64Single", typeof(float), true, true, false, false ),
-		( "ColorRGB96Single", typeof(float), true, true, true, false ),
-		( "ColorRGBA128Single", typeof(float), true, true, true, true ),
-
-		( "ColorR64Double", typeof(double), true, false, false, false ),
-		( "ColorRG128Double", typeof(double), true, true, false, false ),
-		( "ColorRGB192Double", typeof(double), true, true, true, false ),
-		( "ColorRGBA256Double", typeof(double), true, true, true, true ),
-	};
-
 	/// <summary>
 	/// Name, Type, Red, Blue, Green, Alpha, Fully Utilized
 	/// </summary>
-	private static readonly List<(string, Type, bool, bool, bool, bool, bool)> OtherColors = new()
+	private static readonly List<(string, Type, bool, bool, bool, bool, bool)> CustomColors = new()
 	{
 		( "ColorARGB16", typeof(byte), true, true, true, true, false ),
 		( "ColorARGB32", typeof(byte), true, true, true, true, true ),
@@ -65,45 +25,49 @@ internal static class Program
 		( "ColorRGB32Half", typeof(Half), true, true, true, false, false ),
 	};
 
+	/// <summary>
+	/// Name, Red, Blue, Green, Alpha
+	/// </summary>
+	private static readonly List<(string, bool, bool, bool, bool)> GenericColors = new()
+	{
+		( "ColorR", true, false, false, false ),
+		( "ColorRG", true, true, false, false ),
+		( "ColorRGB", true, true, true, false ),
+		( "ColorRGBA", true, true, true, true ),
+		( "ColorA", false, false, false, true ),
+	};
+
 	static void Main()
 	{
-		foreach (var color in Colors)
+		foreach (var customColor in CustomColors)
 		{
-			WriteColor(color);
+			WriteCustomColor(customColor);
 		}
-		foreach (var otherColor in OtherColors)
+		foreach (var genericColor in GenericColors)
 		{
-			WriteOtherColor(otherColor);
+			WriteGenericColor(genericColor);
 		}
 		NumericConversionGenerator.Run();
 		Console.WriteLine("Done!");
 	}
 
-	private static void WriteColor((string, Type, bool, bool, bool, bool) details)
-	{
-		(string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha) = details;
-		Console.WriteLine(name);
-		using FileStream stream = File.Create($"{OutputFolder}{name}.g.cs");
-		using StreamWriter streamWriter = new StreamWriter(stream);
-		streamWriter.NewLine = "\n";
-		using IndentedTextWriter writer = new IndentedTextWriter(streamWriter, "\t");
-		writer.NewLine = "\n";
-		WriteColor(writer, name, type, hasRed, hasGreen, hasBlue, hasAlpha);
-	}
-
-	private static void WriteOtherColor((string, Type, bool, bool, bool, bool, bool) details)
+	private static void WriteCustomColor((string, Type, bool, bool, bool, bool, bool) details)
 	{
 		(string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha, bool fullyUtilized) = details;
 		Console.WriteLine(name);
-		using FileStream stream = File.Create($"{OutputFolder}{name}.g.cs");
-		using StreamWriter streamWriter = new StreamWriter(stream);
-		streamWriter.NewLine = "\n";
-		using IndentedTextWriter writer = new IndentedTextWriter(streamWriter, "\t");
-		writer.NewLine = "\n";
-		WriteOtherColor(writer, name, type, hasRed, hasGreen, hasBlue, hasAlpha, fullyUtilized);
+		using IndentedTextWriter writer = IndentedTextWriterFactory.Create(OutputFolder, name);
+		WriteCustomColor(writer, name, type, hasRed, hasGreen, hasBlue, hasAlpha, fullyUtilized);
 	}
 
-	private static void WriteOtherColor(IndentedTextWriter writer, string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha, bool fullyUtilized)
+	private static void WriteGenericColor((string, bool, bool, bool, bool) details)
+	{
+		(string name, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha) = details;
+		Console.WriteLine(name);
+		using IndentedTextWriter writer = IndentedTextWriterFactory.Create(OutputFolder, name);
+		WriteGenericColor(writer, name, hasRed, hasGreen, hasBlue, hasAlpha);
+	}
+
+	private static void WriteCustomColor(IndentedTextWriter writer, string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha, bool fullyUtilized)
 	{
 		string typeName = CSharpPrimitives.TypeNames[type];
 		writer.WriteLine("//This code is source generated. Do not edit manually.");
@@ -111,19 +75,66 @@ internal static class Program
 		writer.WriteLine($"using {AttributeNamespace};");
 		writer.WriteLine();
 		writer.WriteLine($"namespace {OutputNamespace}");
-		writer.WriteLine('{');
-		writer.Indent++;
+		using (new CurlyBrackets(writer))
+		{
+			WriteRgbaAttribute(writer, hasRed, hasGreen, hasBlue, hasAlpha, fullyUtilized);
+			writer.WriteLine($"public partial struct {name} : IColor<{typeName}>");
+			using (new CurlyBrackets(writer))
+			{
+				WriteHasChannelStaticProperties(writer, hasRed, hasGreen, hasBlue, hasAlpha, typeName);
+				writer.WriteLineNoTabs();
+				WriteToString(writer, hasRed, hasGreen, hasBlue, hasAlpha);
+			}
+		}
+	}
 
+	private static void WriteRgbaAttribute(IndentedTextWriter writer, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha, bool fullyUtilized)
+	{
 		writer.WriteLine($"[RgbaAttribute(RedChannel = {hasRed.ToLowerString()}, GreenChannel = {hasGreen.ToLowerString()}, BlueChannel = {hasBlue.ToLowerString()}, AlphaChannel = {hasAlpha.ToLowerString()}, FullyUtilizedChannels = {fullyUtilized.ToLowerString()})]");
-		writer.WriteLine($"public partial struct {name} : IColor<{typeName}>");
-		writer.WriteLine('{');
-		writer.Indent++;
-		WriteHasChannelStaticProperties(writer, hasRed, hasGreen, hasBlue, hasAlpha, typeName);
-		writer.Indent--;
-		writer.WriteLine('}');
+	}
 
-		writer.Indent--;
-		writer.WriteLine('}');
+	private static void WriteToString(IndentedTextWriter writer, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
+	{
+		writer.WriteLine("public override string ToString()");
+		using (new CurlyBrackets(writer))
+		{
+			StringBuilder sb = new();
+			sb.Append("return $\"{{ ");
+			bool first = true;
+			if (hasRed)
+			{
+				sb.Append("R: {R}");
+				first = false;
+			}
+			if (hasGreen)
+			{
+				if (!first)
+				{
+					sb.Append(", ");
+				}
+				sb.Append("G: {G}");
+				first = false;
+			}
+			if (hasBlue)
+			{
+				if (!first)
+				{
+					sb.Append(", ");
+				}
+				sb.Append("B: {B}");
+				first = false;
+			}
+			if (hasAlpha)
+			{
+				if (!first)
+				{
+					sb.Append(", ");
+				}
+				sb.Append("A: {A}");
+			}
+			sb.Append(" }}\";");
+			writer.WriteLine(sb.ToString());
+		}
 	}
 
 	private static void WriteHasChannelStaticProperties(IndentedTextWriter writer, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha, string typeName)
@@ -134,81 +145,81 @@ internal static class Program
 		writer.WriteLine($"static bool IColor<{typeName}>.HasAlphaChannel => {hasAlpha.ToLowerString()};");
 	}
 
-	private static void WriteColor(IndentedTextWriter writer, string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
+	private static void WriteGenericColor(IndentedTextWriter writer, string name, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
 	{
-		string typeName = CSharpPrimitives.TypeNames[type];
-		writer.WriteLine("//This code is source generated. Do not edit manually.");
-		writer.WriteLine();
+		const string typeName = "T";
+		const string minValue = $"NumericConversion.GetMinimumValue<T>()";
+		const string maxValue = $"NumericConversion.GetMaximumValue<T>()";
+
+		writer.WriteGeneratedCodeWarning();
+		writer.WriteLineNoTabs();
+
 		writer.WriteLine($"using {AttributeNamespace};");
-		writer.WriteLine();
-		writer.WriteLine($"namespace {OutputNamespace}");
-		writer.WriteLine('{');
-		writer.Indent++;
+		writer.WriteLineNoTabs();
 
-		writer.WriteLine($"[RgbaAttribute(RedChannel = {hasRed.ToLowerString()}, GreenChannel = {hasGreen.ToLowerString()}, BlueChannel = {hasBlue.ToLowerString()}, AlphaChannel = {hasAlpha.ToLowerString()}, FullyUtilizedChannels = true)]");
-		writer.WriteLine($"public partial struct {name} : IColor<{typeName}>");
-		writer.WriteLine('{');
-		writer.Indent++;
+		writer.WriteFileScopedNamespace(OutputNamespace);
+		writer.WriteLineNoTabs();
 
-		WriteProperty(writer, hasRed, typeName, 'R', CSharpPrimitives.MinimumValues[type]);
-		writer.WriteLine();
-		WriteProperty(writer, hasGreen, typeName, 'G', CSharpPrimitives.MinimumValues[type]);
-		writer.WriteLine();
-		WriteProperty(writer, hasBlue, typeName, 'B', CSharpPrimitives.MinimumValues[type]);
-		writer.WriteLine();
-		WriteProperty(writer, hasAlpha, typeName, 'A', CSharpPrimitives.MaximumValues[type]);
-		writer.WriteLine();
+		WriteRgbaAttribute(writer, hasRed, hasGreen, hasBlue, hasAlpha, true);
+		string constraints = hasRed && hasGreen && hasBlue && hasAlpha
+			? "unmanaged"
+			: "unmanaged, INumberBase<T>, IMinMaxValue<T>";
+		writer.WriteLine($"public partial struct {name}<T> : IColor<{typeName}> where T : {constraints}");
+		using (new CurlyBrackets(writer))
+		{
+			WriteProperty(writer, hasRed, typeName, 'R', minValue);
+			writer.WriteLineNoTabs();
+			WriteProperty(writer, hasGreen, typeName, 'G', minValue);
+			writer.WriteLineNoTabs();
+			WriteProperty(writer, hasBlue, typeName, 'B', minValue);
+			writer.WriteLineNoTabs();
+			WriteProperty(writer, hasAlpha, typeName, 'A', maxValue);
+			writer.WriteLineNoTabs();
 
-		WriteGetChannels(writer, typeName);
-		writer.WriteLine();
-		WriteSetChannels(writer, type, hasRed, hasGreen, hasBlue, hasAlpha);
-		writer.WriteLine();
-		WriteHasChannelStaticProperties(writer, hasRed, hasGreen, hasBlue, hasAlpha, typeName);
-
-		writer.Indent--;
-		writer.WriteLine('}');
-
-		writer.Indent--;
-		writer.WriteLine('}');
+			WriteGetChannels(writer, typeName);
+			writer.WriteLineNoTabs();
+			WriteSetChannels(writer, typeName, hasRed, hasGreen, hasBlue, hasAlpha);
+			writer.WriteLineNoTabs();
+			WriteHasChannelStaticProperties(writer, hasRed, hasGreen, hasBlue, hasAlpha, typeName);
+			writer.WriteLineNoTabs();
+			WriteToString(writer, hasRed, hasGreen, hasBlue, hasAlpha);
+		}
 	}
 
 	private static void WriteGetChannels(IndentedTextWriter writer, string typeName)
 	{
 		writer.WriteLine($"public readonly void GetChannels(out {typeName} r, out {typeName} g, out {typeName} b, out {typeName} a)");
-		writer.WriteLine('{');
-		writer.Indent++;
-		writer.WriteLine("r = R;");
-		writer.WriteLine("g = G;");
-		writer.WriteLine("b = B;");
-		writer.WriteLine("a = A;");
-		writer.Indent--;
-		writer.WriteLine('}');
+		using (new CurlyBrackets(writer))
+		{
+			writer.WriteLine("r = R;");
+			writer.WriteLine("g = G;");
+			writer.WriteLine("b = B;");
+			writer.WriteLine("a = A;");
+		}
 	}
 
-	private static void WriteSetChannels(IndentedTextWriter writer, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
+	private static void WriteSetChannels(IndentedTextWriter writer, string typeName, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
 	{
-		string typeName = CSharpPrimitives.TypeNames[type];
 		writer.WriteLine($"public void SetChannels({typeName} r, {typeName} g, {typeName} b, {typeName} a)");
-		writer.WriteLine('{');
-		writer.Indent++;
-		if (hasRed)
+		using (new CurlyBrackets(writer))
 		{
-			writer.WriteLine("R = r;");
+			if (hasRed)
+			{
+				writer.WriteLine("R = r;");
+			}
+			if (hasGreen)
+			{
+				writer.WriteLine("G = g;");
+			}
+			if (hasBlue)
+			{
+				writer.WriteLine("B = b;");
+			}
+			if (hasAlpha)
+			{
+				writer.WriteLine("A = a;");
+			}
 		}
-		if (hasGreen)
-		{
-			writer.WriteLine("G = g;");
-		}
-		if (hasBlue)
-		{
-			writer.WriteLine("B = b;");
-		}
-		if (hasAlpha)
-		{
-			writer.WriteLine("A = a;");
-		}
-		writer.Indent--;
-		writer.WriteLine('}');
 	}
 
 	private static void WriteProperty(IndentedTextWriter writer, bool hasColor, string typeName, char channel, string defaultValue)
@@ -220,12 +231,11 @@ internal static class Program
 		else
 		{
 			writer.WriteLine($"public readonly {typeName} {channel} ");
-			writer.WriteLine('{');
-			writer.Indent++;
-			writer.WriteLine($"get => {defaultValue};");
-			writer.WriteLine("set { }");
-			writer.Indent--;
-			writer.WriteLine('}');
+			using (new CurlyBrackets(writer))
+			{
+				writer.WriteLine($"get => {defaultValue};");
+				writer.WriteLine("set { }");
+			}
 		}
 	}
 
diff --git a/AssetRipper.TextureDecoder.ConsoleApp/DirectBitmap.cs b/AssetRipper.TextureDecoder.ConsoleApp/DirectBitmap.cs
index 90640ac..a18420b 100644
--- a/AssetRipper.TextureDecoder.ConsoleApp/DirectBitmap.cs
+++ b/AssetRipper.TextureDecoder.ConsoleApp/DirectBitmap.cs
@@ -96,24 +96,24 @@ public readonly struct DirectBitmap<TColor, TColorArg>
 
 	private void GetDataAndComponentsForSaving(out byte[] data, out ColorComponents components)
 	{
-		if (typeof(TColor) == typeof(ColorRGBA32))
+		if (typeof(TColor) == typeof(ColorRGBA<byte>))
 		{
 			data = Data;
 			components = ColorComponents.RedGreenBlueAlpha;
 		}
-		else if (typeof(TColor) == typeof(ColorRGB24))
+		else if (typeof(TColor) == typeof(ColorRGB<byte>))
 		{
 			data = Data;
 			components = ColorComponents.RedGreenBlue;
 		}
 		else if (TColor.HasAlphaChannel)
 		{
-			RgbConverter.Convert<TColor, TColorArg, ColorRGBA32, byte>(Bits, Width, Height, out data);
+			RgbConverter.Convert<TColor, TColorArg, ColorRGBA<byte>, byte>(Bits, Width, Height, out data);
 			components = ColorComponents.RedGreenBlueAlpha;
 		}
 		else
 		{
-			RgbConverter.Convert<TColor, TColorArg, ColorRGB24, byte>(Bits, Width, Height, out data);
+			RgbConverter.Convert<TColor, TColorArg, ColorRGB<byte>, byte>(Bits, Width, Height, out data);
 			components = ColorComponents.RedGreenBlue;
 		}
 	}
diff --git a/AssetRipper.TextureDecoder.ConsoleApp/Program.g.cs b/AssetRipper.TextureDecoder.ConsoleApp/Program.g.cs
index 83edc65..af67f6b 100644
--- a/AssetRipper.TextureDecoder.ConsoleApp/Program.g.cs
+++ b/AssetRipper.TextureDecoder.ConsoleApp/Program.g.cs
@@ -1,4 +1,4 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
 using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
@@ -9,152 +9,276 @@ static partial class Program
 	private static void DecodeRgb(ReadOnlySpan<byte> input, int width, int height, string modeString, Span<byte> output)
 	{
 		Console.WriteLine("Arg at index 5 : mode");
-		Console.WriteLine("  0 - A8");
-		Console.WriteLine("  1 - ARGB16");
-		Console.WriteLine("  2 - ARGB32");
-		Console.WriteLine("  3 - BGRA32");
-		Console.WriteLine("  4 - R16");
-		Console.WriteLine("  5 - R16Half");
-		Console.WriteLine("  6 - R16Signed");
-		Console.WriteLine("  7 - R32Single");
-		Console.WriteLine("  8 - R64Double");
-		Console.WriteLine("  9 - R8");
-		Console.WriteLine("  10 - R8Signed");
-		Console.WriteLine("  11 - RG16");
-		Console.WriteLine("  12 - RG32Half");
-		Console.WriteLine("  13 - RG16Signed");
-		Console.WriteLine("  14 - RG32");
-		Console.WriteLine("  15 - RG32Signed");
-		Console.WriteLine("  16 - RG64Single");
-		Console.WriteLine("  17 - RG128Double");
-		Console.WriteLine("  18 - RGB16");
-		Console.WriteLine("  19 - RGB24");
-		Console.WriteLine("  20 - RGB24Signed");
-		Console.WriteLine("  21 - RGB32Half");
-		Console.WriteLine("  22 - RGB48");
-		Console.WriteLine("  23 - RGB48Half");
-		Console.WriteLine("  24 - RGB48Signed");
-		Console.WriteLine("  25 - RGB96Single");
-		Console.WriteLine("  26 - RGB192Double");
-		Console.WriteLine("  27 - RGB9e5");
-		Console.WriteLine("  28 - RGBA128Single");
-		Console.WriteLine("  29 - RGBA16");
-		Console.WriteLine("  30 - RGBA256Double");
-		Console.WriteLine("  31 - RGBA32");
-		Console.WriteLine("  32 - RGBA32Signed");
-		Console.WriteLine("  33 - RGBA64");
-		Console.WriteLine("  34 - RGBA64Half");
-		Console.WriteLine("  35 - RGBA64Signed");
+		Console.WriteLine("  0 - R8SByte");
+		Console.WriteLine("  1 - RG8SByte");
+		Console.WriteLine("  2 - RGB8SByte");
+		Console.WriteLine("  3 - RGBA8SByte");
+		Console.WriteLine("  4 - A8SByte");
+		Console.WriteLine("  5 - R8Byte");
+		Console.WriteLine("  6 - RG8Byte");
+		Console.WriteLine("  7 - RGB8Byte");
+		Console.WriteLine("  8 - RGBA8Byte");
+		Console.WriteLine("  9 - A8Byte");
+		Console.WriteLine("  10 - R16Int16");
+		Console.WriteLine("  11 - RG16Int16");
+		Console.WriteLine("  12 - RGB16Int16");
+		Console.WriteLine("  13 - RGBA16Int16");
+		Console.WriteLine("  14 - A16Int16");
+		Console.WriteLine("  15 - R16UInt16");
+		Console.WriteLine("  16 - RG16UInt16");
+		Console.WriteLine("  17 - RGB16UInt16");
+		Console.WriteLine("  18 - RGBA16UInt16");
+		Console.WriteLine("  19 - A16UInt16");
+		Console.WriteLine("  20 - R32Int32");
+		Console.WriteLine("  21 - RG32Int32");
+		Console.WriteLine("  22 - RGB32Int32");
+		Console.WriteLine("  23 - RGBA32Int32");
+		Console.WriteLine("  24 - A32Int32");
+		Console.WriteLine("  25 - R32UInt32");
+		Console.WriteLine("  26 - RG32UInt32");
+		Console.WriteLine("  27 - RGB32UInt32");
+		Console.WriteLine("  28 - RGBA32UInt32");
+		Console.WriteLine("  29 - A32UInt32");
+		Console.WriteLine("  30 - R64Int64");
+		Console.WriteLine("  31 - RG64Int64");
+		Console.WriteLine("  32 - RGB64Int64");
+		Console.WriteLine("  33 - RGBA64Int64");
+		Console.WriteLine("  34 - A64Int64");
+		Console.WriteLine("  35 - R64UInt64");
+		Console.WriteLine("  36 - RG64UInt64");
+		Console.WriteLine("  37 - RGB64UInt64");
+		Console.WriteLine("  38 - RGBA64UInt64");
+		Console.WriteLine("  39 - A64UInt64");
+		Console.WriteLine("  40 - R16Half");
+		Console.WriteLine("  41 - RG16Half");
+		Console.WriteLine("  42 - RGB16Half");
+		Console.WriteLine("  43 - RGBA16Half");
+		Console.WriteLine("  44 - A16Half");
+		Console.WriteLine("  45 - R32Single");
+		Console.WriteLine("  46 - RG32Single");
+		Console.WriteLine("  47 - RGB32Single");
+		Console.WriteLine("  48 - RGBA32Single");
+		Console.WriteLine("  49 - A32Single");
+		Console.WriteLine("  50 - R64Double");
+		Console.WriteLine("  51 - RG64Double");
+		Console.WriteLine("  52 - RGB64Double");
+		Console.WriteLine("  53 - RGBA64Double");
+		Console.WriteLine("  54 - A64Double");
+		Console.WriteLine("  55 - R128Decimal");
+		Console.WriteLine("  56 - RG128Decimal");
+		Console.WriteLine("  57 - RGB128Decimal");
+		Console.WriteLine("  58 - RGBA128Decimal");
+		Console.WriteLine("  59 - A128Decimal");
+		Console.WriteLine("  60 - ARGB16");
+		Console.WriteLine("  61 - ARGB32");
+		Console.WriteLine("  62 - BGRA32");
+		Console.WriteLine("  63 - RGB16");
+		Console.WriteLine("  64 - RGB32Half");
+		Console.WriteLine("  65 - RGB9e5");
+		Console.WriteLine("  66 - RGBA16");
 		int mode = int.Parse(modeString);
 		switch(mode)
 		{
 			case 0:
-				RgbConverter.Convert<ColorA8, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<sbyte>, sbyte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 1:
-				RgbConverter.Convert<ColorARGB16, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<sbyte>, sbyte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 2:
-				RgbConverter.Convert<ColorARGB32, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<sbyte>, sbyte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 3:
-				RgbConverter.Convert<ColorBGRA32, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<sbyte>, sbyte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 4:
-				RgbConverter.Convert<ColorR16, ushort, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<sbyte>, sbyte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 5:
-				RgbConverter.Convert<ColorR16Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<byte>, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 6:
-				RgbConverter.Convert<ColorR16Signed, short, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<byte>, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 7:
-				RgbConverter.Convert<ColorR32Single, float, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<byte>, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 8:
-				RgbConverter.Convert<ColorR64Double, double, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 9:
-				RgbConverter.Convert<ColorR8, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<byte>, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 10:
-				RgbConverter.Convert<ColorR8Signed, sbyte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<short>, short, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 11:
-				RgbConverter.Convert<ColorRG16, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<short>, short, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 12:
-				RgbConverter.Convert<ColorRG32Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<short>, short, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 13:
-				RgbConverter.Convert<ColorRG16Signed, sbyte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<short>, short, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 14:
-				RgbConverter.Convert<ColorRG32, ushort, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<short>, short, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 15:
-				RgbConverter.Convert<ColorRG32Signed, short, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<ushort>, ushort, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 16:
-				RgbConverter.Convert<ColorRG64Single, float, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<ushort>, ushort, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 17:
-				RgbConverter.Convert<ColorRG128Double, double, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<ushort>, ushort, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 18:
-				RgbConverter.Convert<ColorRGB16, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<ushort>, ushort, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 19:
-				RgbConverter.Convert<ColorRGB24, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<ushort>, ushort, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 20:
-				RgbConverter.Convert<ColorRGB24Signed, sbyte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<int>, int, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 21:
-				RgbConverter.Convert<ColorRGB32Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<int>, int, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 22:
-				RgbConverter.Convert<ColorRGB48, ushort, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<int>, int, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 23:
-				RgbConverter.Convert<ColorRGB48Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<int>, int, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 24:
-				RgbConverter.Convert<ColorRGB48Signed, short, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<int>, int, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 25:
-				RgbConverter.Convert<ColorRGB96Single, float, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<uint>, uint, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 26:
-				RgbConverter.Convert<ColorRGB192Double, double, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<uint>, uint, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 27:
-				RgbConverter.Convert<ColorRGB9e5, double, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<uint>, uint, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 28:
-				RgbConverter.Convert<ColorRGBA128Single, float, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<uint>, uint, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 29:
-				RgbConverter.Convert<ColorRGBA16, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<uint>, uint, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 30:
-				RgbConverter.Convert<ColorRGBA256Double, double, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<long>, long, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 31:
-				RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRG<long>, long, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 32:
-				RgbConverter.Convert<ColorRGBA32Signed, sbyte, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGB<long>, long, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 33:
-				RgbConverter.Convert<ColorRGBA64, ushort, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorRGBA<long>, long, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 34:
-				RgbConverter.Convert<ColorRGBA64Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorA<long>, long, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			case 35:
-				RgbConverter.Convert<ColorRGBA64Signed, short, ColorBGRA32, byte>(input, width, height, output);
+				RgbConverter.Convert<ColorR<ulong>, ulong, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 36:
+				RgbConverter.Convert<ColorRG<ulong>, ulong, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 37:
+				RgbConverter.Convert<ColorRGB<ulong>, ulong, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 38:
+				RgbConverter.Convert<ColorRGBA<ulong>, ulong, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 39:
+				RgbConverter.Convert<ColorA<ulong>, ulong, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 40:
+				RgbConverter.Convert<ColorR<Half>, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 41:
+				RgbConverter.Convert<ColorRG<Half>, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 42:
+				RgbConverter.Convert<ColorRGB<Half>, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 43:
+				RgbConverter.Convert<ColorRGBA<Half>, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 44:
+				RgbConverter.Convert<ColorA<Half>, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 45:
+				RgbConverter.Convert<ColorR<float>, float, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 46:
+				RgbConverter.Convert<ColorRG<float>, float, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 47:
+				RgbConverter.Convert<ColorRGB<float>, float, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 48:
+				RgbConverter.Convert<ColorRGBA<float>, float, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 49:
+				RgbConverter.Convert<ColorA<float>, float, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 50:
+				RgbConverter.Convert<ColorR<double>, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 51:
+				RgbConverter.Convert<ColorRG<double>, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 52:
+				RgbConverter.Convert<ColorRGB<double>, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 53:
+				RgbConverter.Convert<ColorRGBA<double>, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 54:
+				RgbConverter.Convert<ColorA<double>, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 55:
+				RgbConverter.Convert<ColorR<decimal>, decimal, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 56:
+				RgbConverter.Convert<ColorRG<decimal>, decimal, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 57:
+				RgbConverter.Convert<ColorRGB<decimal>, decimal, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 58:
+				RgbConverter.Convert<ColorRGBA<decimal>, decimal, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 59:
+				RgbConverter.Convert<ColorA<decimal>, decimal, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 60:
+				RgbConverter.Convert<ColorARGB16, byte, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 61:
+				RgbConverter.Convert<ColorARGB32, byte, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 62:
+				RgbConverter.Convert<ColorBGRA32, byte, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 63:
+				RgbConverter.Convert<ColorRGB16, byte, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 64:
+				RgbConverter.Convert<ColorRGB32Half, Half, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 65:
+				RgbConverter.Convert<ColorRGB9e5, double, ColorBGRA32, byte>(input, width, height, output);
+				break;
+			case 66:
+				RgbConverter.Convert<ColorRGBA16, byte, ColorBGRA32, byte>(input, width, height, output);
 				break;
 			default:
 				throw new NotSupportedException(mode.ToString());
diff --git a/AssetRipper.TextureDecoder.SourceGeneration.Common/AssetRipper.TextureDecoder.SourceGeneration.Common.csproj b/AssetRipper.TextureDecoder.SourceGeneration.Common/AssetRipper.TextureDecoder.SourceGeneration.Common.csproj
new file mode 100644
index 0000000..6b0142d
--- /dev/null
+++ b/AssetRipper.TextureDecoder.SourceGeneration.Common/AssetRipper.TextureDecoder.SourceGeneration.Common.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net7.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+</Project>
diff --git a/AssetRipper.TextureDecoder.ColorGenerator/CSharpPrimitives.cs b/AssetRipper.TextureDecoder.SourceGeneration.Common/CSharpPrimitives.cs
similarity index 52%
rename from AssetRipper.TextureDecoder.ColorGenerator/CSharpPrimitives.cs
rename to AssetRipper.TextureDecoder.SourceGeneration.Common/CSharpPrimitives.cs
index b99ffb9..1fb2ac5 100644
--- a/AssetRipper.TextureDecoder.ColorGenerator/CSharpPrimitives.cs
+++ b/AssetRipper.TextureDecoder.SourceGeneration.Common/CSharpPrimitives.cs
@@ -1,10 +1,11 @@
-using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
-namespace AssetRipper.TextureDecoder.ColorGenerator;
+namespace AssetRipper.TextureDecoder.SourceGeneration.Common;
 
-internal static class CSharpPrimitives
+public static class CSharpPrimitives
 {
-	internal static IReadOnlyDictionary<Type, string> MinimumValues { get; } = new Dictionary<Type, string>()
+	public static IReadOnlyDictionary<Type, string> MinimumValues { get; } = new Dictionary<Type, string>()
 	{
 		{ typeof(sbyte), "sbyte.MinValue" },
 		{ typeof(byte), "byte.MinValue" },
@@ -20,7 +21,7 @@ internal static class CSharpPrimitives
 		{ typeof(decimal), "0m" },
 	};
 
-	internal static IReadOnlyDictionary<Type, string> MaximumValues { get; } = new Dictionary<Type, string>()
+	public static IReadOnlyDictionary<Type, string> MaximumValues { get; } = new Dictionary<Type, string>()
 	{
 		{ typeof(sbyte), "sbyte.MaxValue" },
 		{ typeof(byte), "byte.MaxValue" },
@@ -36,7 +37,7 @@ internal static class CSharpPrimitives
 		{ typeof(decimal), "1m" },
 	};
 
-	internal static IReadOnlyDictionary<Type, string> TypeNames { get; } = new Dictionary<Type, string>()
+	public static IReadOnlyDictionary<Type, string> TypeNames { get; } = new Dictionary<Type, string>()
 	{
 		{ typeof(sbyte), "sbyte" },
 		{ typeof(byte), "byte" },
@@ -52,7 +53,7 @@ internal static class CSharpPrimitives
 		{ typeof(decimal), "decimal" },
 	};
 
-	internal static IReadOnlyDictionary<Type, int> Sizes { get; } = new Dictionary<Type, int>()
+	public static IReadOnlyDictionary<Type, int> Sizes { get; } = new Dictionary<Type, int>()
 	{
 		{ typeof(sbyte), sizeof(sbyte) },
 		{ typeof(byte), sizeof(byte) },
@@ -68,7 +69,42 @@ internal static class CSharpPrimitives
 		{ typeof(decimal), sizeof(decimal) }
 	};
 
-	internal static IEnumerable<Type> Types => TypeNames.Keys;
+	public static IEnumerable<Type> Types => TypeNames.Keys;
 
-	internal static Type FirstType { get; } = Types.First();
+	public static Type FirstType { get; } = Types.First();
+
+	public static bool IsFloatingPoint(Type type)
+	{
+		return type == typeof(Half) || type == typeof(float) || type == typeof(double) || type == typeof(decimal);
+	}
+
+	public static bool IsSignedInteger(Type type, [NotNullWhen(true)] out Type? unsignedType)
+	{
+		if (type == typeof(sbyte))
+		{
+			unsignedType = typeof(byte);
+		}
+		else if (type == typeof(short))
+		{
+			unsignedType = typeof(ushort);
+		}
+		else if (type == typeof(int))
+		{
+			unsignedType = typeof(uint);
+		}
+		else if (type == typeof(long))
+		{
+			unsignedType = typeof(ulong);
+		}
+		else
+		{
+			unsignedType = null;
+		}
+		return unsignedType is not null;
+	}
+
+	public static bool IsUnsignedInteger(Type type)
+	{
+		return type == typeof(byte) || type == typeof(ushort) || type == typeof(uint) || type == typeof(ulong);
+	}
 }
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder.TestGenerator/AssetRipper.TextureDecoder.TestGenerator.csproj b/AssetRipper.TextureDecoder.TestGenerator/AssetRipper.TextureDecoder.TestGenerator.csproj
index 360e5a2..35997c7 100644
--- a/AssetRipper.TextureDecoder.TestGenerator/AssetRipper.TextureDecoder.TestGenerator.csproj
+++ b/AssetRipper.TextureDecoder.TestGenerator/AssetRipper.TextureDecoder.TestGenerator.csproj
@@ -8,7 +8,12 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+		<ProjectReference Include="..\AssetRipper.TextureDecoder.SourceGeneration.Common\AssetRipper.TextureDecoder.SourceGeneration.Common.csproj" />
 		<ProjectReference Include="..\AssetRipper.TextureDecoder\AssetRipper.TextureDecoder.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+		<PackageReference Include="AssetRipper.Text.SourceGeneration" Version="1.0.0" />
+	</ItemGroup>
+
 </Project>
diff --git a/AssetRipper.TextureDecoder.TestGenerator/ColorRandomValues.cs b/AssetRipper.TextureDecoder.TestGenerator/ColorRandomValues.cs
deleted file mode 100644
index cd0baa2..0000000
--- a/AssetRipper.TextureDecoder.TestGenerator/ColorRandomValues.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-namespace AssetRipper.TextureDecoder.TestGenerator
-{
-	internal struct ColorRandomValues
-	{
-		public string DefaultR;
-		public string DefaultG;
-		public string DefaultB;
-		public string DefaultA;
-		public string SetValue;
-
-		public ColorRandomValues(string defaultR, string defaultG, string defaultB, string defaultA, string setValue)
-		{
-			DefaultR = defaultR;
-			DefaultG = defaultG;
-			DefaultB = defaultB;
-			DefaultA = defaultA;
-			SetValue = setValue;
-		}
-	}
-}
diff --git a/AssetRipper.TextureDecoder.TestGenerator/GenerationData.cs b/AssetRipper.TextureDecoder.TestGenerator/GenerationData.cs
index 832dd44..8348943 100644
--- a/AssetRipper.TextureDecoder.TestGenerator/GenerationData.cs
+++ b/AssetRipper.TextureDecoder.TestGenerator/GenerationData.cs
@@ -1,5 +1,6 @@
 using AssetRipper.TextureDecoder.Attributes;
 using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.SourceGeneration.Common;
 using System.Reflection;
 
 namespace AssetRipper.TextureDecoder.TestGenerator
@@ -16,57 +17,11 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 		public bool AlphaChannel { get; }
 		public bool FullyUtilizedChannels { get; }
 
-		public bool IsFloatingPoint
-		{
-			get
-			{
-				return ChannelType == typeof(Half) || ChannelType == typeof(float) || ChannelType == typeof(double);
-			}
-		}
+		public bool IsFloatingPoint => CSharpPrimitives.IsFloatingPoint(ChannelType);
 
-		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 int BitSizePerChannel => CSharpPrimitives.Sizes[ChannelType] * 8;
 
-		public string ChannelTypeName
-		{
-			get
-			{
-				return ChannelType.Name switch
-				{
-					"Byte" => "byte",
-					"SByte" => "sbyte",
-					"UInt16" => "ushort",
-					"Int16" => "short",
-					"Single" => "float",
-					"Double" => "double",
-					_ => ChannelType.Name,
-				};
-			}
-		}
+		public string ChannelTypeName => CSharpPrimitives.TypeNames[ChannelType];
 
 		public GenerationData(Type colorType, int colorSize)
 		{
@@ -89,12 +44,7 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 				return false;
 			}
 
-			if (!IsFloatingPoint && other.IsFloatingPoint)
-			{
-				return false;
-			}
-			
-			if (IsFloatingPoint && !other.IsFloatingPoint)
+			if (IsFloatingPoint != other.IsFloatingPoint)
 			{
 				return false;
 			}
diff --git a/AssetRipper.TextureDecoder.TestGenerator/IndentedTextWriterExtensions.cs b/AssetRipper.TextureDecoder.TestGenerator/IndentedTextWriterExtensions.cs
deleted file mode 100644
index d23664d..0000000
--- a/AssetRipper.TextureDecoder.TestGenerator/IndentedTextWriterExtensions.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System.CodeDom.Compiler;
-
-internal static class IndentedTextWriterExtensions
-{
-	internal static void WriteSourceGenerationDisclaimer(this IndentedTextWriter textWriter)
-	{
-		textWriter.WriteLine($"//This code is source generated. Do not edit manually.");
-		textWriter.WriteLine();
-	}
-}
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder.TestGenerator/Program.cs b/AssetRipper.TextureDecoder.TestGenerator/Program.cs
index d705b45..7f1ceb2 100644
--- a/AssetRipper.TextureDecoder.TestGenerator/Program.cs
+++ b/AssetRipper.TextureDecoder.TestGenerator/Program.cs
@@ -1,5 +1,7 @@
-using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.Text.SourceGeneration;
+using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
+using AssetRipper.TextureDecoder.SourceGeneration.Common;
 using System.CodeDom.Compiler;
 
 namespace AssetRipper.TextureDecoder.TestGenerator
@@ -8,42 +10,13 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 	{
 		internal static readonly List<GenerationData> dataList = new()
 		{
-			new GenerationData(typeof(ColorA8), 1),
 			new GenerationData(typeof(ColorARGB16), 2),
 			new GenerationData(typeof(ColorARGB32), 4),
 			new GenerationData(typeof(ColorBGRA32), 4),
-			new GenerationData(typeof(ColorR16), 2),
-			new GenerationData(typeof(ColorR16Half), 2),
-			new GenerationData(typeof(ColorR16Signed), 2),
-			new GenerationData(typeof(ColorR32Single), 4),
-			new GenerationData(typeof(ColorR64Double), 8),
-			new GenerationData(typeof(ColorR8), 1),
-			new GenerationData(typeof(ColorR8Signed), 1),
-			new GenerationData(typeof(ColorRG16), 2),
-			new GenerationData(typeof(ColorRG32Half), 4),
-			new GenerationData(typeof(ColorRG16Signed), 2),
-			new GenerationData(typeof(ColorRG32), 4),
-			new GenerationData(typeof(ColorRG32Signed), 4),
-			new GenerationData(typeof(ColorRG64Single), 8),
-			new GenerationData(typeof(ColorRG128Double), 16),
 			new GenerationData(typeof(ColorRGB16), 2),
-			new GenerationData(typeof(ColorRGB24), 3),
-			new GenerationData(typeof(ColorRGB24Signed), 3),
 			new GenerationData(typeof(ColorRGB32Half), 4),
-			new GenerationData(typeof(ColorRGB48), 6),
-			new GenerationData(typeof(ColorRGB48Half), 6),
-			new GenerationData(typeof(ColorRGB48Signed), 6),
-			new GenerationData(typeof(ColorRGB96Single), 12),
-			new GenerationData(typeof(ColorRGB192Double), 24),
 			new GenerationData(typeof(ColorRGB9e5), 4),
-			new GenerationData(typeof(ColorRGBA128Single), 16),
 			new GenerationData(typeof(ColorRGBA16), 2),
-			new GenerationData(typeof(ColorRGBA256Double), 32),
-			new GenerationData(typeof(ColorRGBA32), 4),
-			new GenerationData(typeof(ColorRGBA32Signed), 4),
-			new GenerationData(typeof(ColorRGBA64), 8),
-			new GenerationData(typeof(ColorRGBA64Half), 8),
-			new GenerationData(typeof(ColorRGBA64Signed), 8),
 		};
 
 		static void Main()
@@ -55,64 +28,69 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 
 		private static void GenerateRgbConsoleMethod()
 		{
-			StringWriter streamWriter = new();
-			IndentedTextWriter textWriter = new IndentedTextWriter(streamWriter, "\t");
-			streamWriter.NewLine = "\n";
-			textWriter.NewLine = "\n";
-
-			textWriter.WriteSourceGenerationDisclaimer();
-			textWriter.WriteLine($"using {typeof(RgbConverter).Namespace};");
-			textWriter.WriteLine($"using {typeof(ColorBGRA32).Namespace};");
-			textWriter.WriteLine();
-
-			textWriter.WriteLine("namespace AssetRipper.TextureDecoder.ConsoleApp;");
-			textWriter.WriteLine("static partial class Program");
-			textWriter.WriteLine("{");
-			textWriter.Indent++;
-
-			textWriter.WriteLine("private static void DecodeRgb(ReadOnlySpan<byte> input, int width, int height, string modeString, Span<byte> output)");
-			textWriter.WriteLine("{");
-			textWriter.Indent++;
-
-			textWriter.WriteLine("Console.WriteLine(\"Arg at index 5 : mode\");");
-			for (int i = 0; i < dataList.Count; i++)
-			{
-				textWriter.WriteLine($"Console.WriteLine(\"  {i} - {dataList[i].ColorType.Name.Substring(5)}\");");
-			}
-			textWriter.WriteLine("int mode = int.Parse(modeString);");
-			textWriter.WriteLine("switch(mode)");
-			textWriter.WriteLine("{");
-			textWriter.Indent++;
-
-			for (int i = 0; i < dataList.Count; i++)
-			{
-				textWriter.WriteLine($"case {i}:");
-				textWriter.Indent++;
-				GenerationData data = dataList[i];
-				textWriter.WriteLine($"RgbConverter.Convert<{data.ColorType.Name}, {data.ChannelTypeName}, ColorBGRA32, byte>(input, width, height, output);");
-				textWriter.WriteLine("break;");
-				textWriter.Indent--;
-			}
-			{
-				textWriter.WriteLine("default:");
-				textWriter.Indent++;
-				textWriter.WriteLine("throw new NotSupportedException(mode.ToString());");
-				textWriter.Indent--;
-			}
-
-			textWriter.Indent--;
-			textWriter.WriteLine("}");
-
-			textWriter.Indent--;
-			textWriter.WriteLine("}");
-
-			textWriter.Indent--;
-			textWriter.WriteLine("}");
-
-			textWriter.Flush();
-			streamWriter.Flush();
-			File.WriteAllText("../../../../AssetRipper.TextureDecoder.ConsoleApp/Program.g.cs", streamWriter.ToString());
 			Console.WriteLine("Program");
+			using IndentedTextWriter writer = IndentedTextWriterFactory.Create("../../../../AssetRipper.TextureDecoder.ConsoleApp", "Program");
+
+			writer.WriteGeneratedCodeWarning();
+			writer.WriteLine();
+			writer.WriteLine($"using {typeof(RgbConverter).Namespace};");
+			writer.WriteLine($"using {typeof(ColorBGRA32).Namespace};");
+			writer.WriteLine();
+
+			writer.WriteFileScopedNamespace("AssetRipper.TextureDecoder.ConsoleApp");
+			writer.WriteLine("static partial class Program");
+			using (new CurlyBrackets(writer))
+			{
+				writer.WriteLine("private static void DecodeRgb(ReadOnlySpan<byte> input, int width, int height, string modeString, Span<byte> output)");
+				using (new CurlyBrackets(writer))
+				{
+					List<(string, string, string)> list = GetColorNames().ToList();
+					writer.WriteLine("Console.WriteLine(\"Arg at index 5 : mode\");");
+					for (int i = 0; i < list.Count; i++)
+					{
+						writer.WriteLine($"Console.WriteLine(\"  {i} - {list[i].Item1.Substring(5)}\");");
+					}
+					writer.WriteLine("int mode = int.Parse(modeString);");
+					writer.WriteLine("switch(mode)");
+					using (new CurlyBrackets(writer))
+					{
+						for (int i = 0 ; i < list.Count; i++)
+						{
+							(string prettyName, string colorName, string channelName) = list[i];
+							writer.WriteLine($"case {i}:");
+							using (new IndentedBlock(writer))
+							{
+								writer.WriteLine($"RgbConverter.Convert<{colorName}, {channelName}, ColorBGRA32, byte>(input, width, height, output);");
+								writer.WriteLine("break;");
+							}
+						}
+						{
+							writer.WriteLine("default:");
+							using (new IndentedBlock(writer))
+							{
+								writer.WriteLine("throw new NotSupportedException(mode.ToString());");
+							}
+						}
+					}
+				}
+			}
+
+			static IEnumerable<(string, string, string)> GetColorNames()
+			{
+				foreach ((Type primitiveType, string primitiveName) in CSharpPrimitives.TypeNames)
+				{
+					int primitiveBitSize = CSharpPrimitives.Sizes[primitiveType] * 8;
+					foreach (string genericColorName in TestClassGenerator.GetGenericColorNames())
+					{
+						string prettyName = $"{genericColorName}{primitiveBitSize}{primitiveType.Name}";
+						yield return (prettyName, $"{genericColorName}<{primitiveName}>", primitiveName);
+					}
+				}
+				foreach (GenerationData data in dataList)
+				{
+					yield return (data.ColorType.Name, data.ColorType.Name, data.ChannelTypeName);
+				}
+			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder.TestGenerator/TestClassGenerator.cs b/AssetRipper.TextureDecoder.TestGenerator/TestClassGenerator.cs
index 77e0ab5..09a3af0 100644
--- a/AssetRipper.TextureDecoder.TestGenerator/TestClassGenerator.cs
+++ b/AssetRipper.TextureDecoder.TestGenerator/TestClassGenerator.cs
@@ -1,4 +1,7 @@
-using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.Text.SourceGeneration;
+using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.Rgb.Formats;
+using AssetRipper.TextureDecoder.SourceGeneration.Common;
 using AssetRipper.TextureDecoder.TestGenerator;
 using System.CodeDom.Compiler;
 
@@ -9,51 +12,86 @@ internal static class TestClassGenerator
 
 	private static readonly char[] channels = new char[] { 'R', 'G', 'B', 'A' };
 
-	private static readonly Dictionary<Type, ColorRandomValues> randomValueDictionary = new()
-		{
-			{ typeof(sbyte), new ColorRandomValues("-0b01010101", "0b01110010", "-0b00001111", "-0b01000111", "0b01001110") },
-			{ typeof(byte), new ColorRandomValues("0b11010101", "0b01110010", "0b10001111", "0b11000111", "0b01001110") },
-			{ typeof(short), new ColorRandomValues("-24000", "21354", "-80", "347", "31871") },
-			{ typeof(ushort), new ColorRandomValues("44000", "21354", "60080", "347", "33871") },
-			{ typeof(Half), new ColorRandomValues("(Half)0.447f", "(Half)0.224f", "(Half)0.95f", "(Half)0.897f", "(Half)0.333f") },
-			{ typeof(float), new ColorRandomValues("0.447f", "0.224f", "0.95f", "0.897f", "0.333f") },
-			{ typeof(double), new ColorRandomValues("0.447", "0.224", "0.95", "0.897", "0.333") },
-		};
-
 	internal static void GenerateTestClasses()
 	{
 		Directory.CreateDirectory(OutputFolder);
-
+		MakeGenericColorTests();
+		MakeLosslessColorTests();
 		foreach (GenerationData data in Program.dataList)
 		{
 			using StringWriter streamWriter = new();
 			using IndentedTextWriter textWriter = new IndentedTextWriter(streamWriter, "\t");
 			streamWriter.NewLine = "\n";
 			textWriter.NewLine = "\n";
-			textWriter.WriteSourceGenerationDisclaimer();
-			textWriter.WriteNamespaceUsings(data);
+			textWriter.WriteGeneratedCodeWarning();
+			textWriter.WriteLineNoTabs();
+			textWriter.WriteNamespaceUsings(data.ColorType.Namespace);
 			textWriter.WriteFileScopedNamespace();
 			textWriter.WriteClassDefinitionOpen(data);
 			textWriter.Indent++;
 			textWriter.WriteCorrectSizeTest(data);
-			textWriter.WriteLine();
+			textWriter.WriteLineNoTabs();
 			textWriter.WritePropertySymmetryTests(data);
 			textWriter.WriteIndependenceTests(data);
 			textWriter.WriteGetMethodMatchesProperties();
-			textWriter.WriteLine();
+			textWriter.WriteLineNoTabs();
 			textWriter.WriteMethodSymmetryTest();
-			textWriter.WriteLine();
+			textWriter.WriteLineNoTabs();
 			textWriter.WriteMakeRandomColor(data);
+			textWriter.WriteLineNoTabs();
+			textWriter.WriteMakeRandomValue(data);
 
 			foreach (GenerationData otherData in Program.dataList)
 			{
 				if (otherData.Contains(data))
 				{
-					textWriter.WriteLine();
+					textWriter.WriteLineNoTabs();
 					textWriter.WriteLosslessConversionTest(data, otherData);
 				}
 			}
 
+			foreach ((Type channelType, string channelTypeName) in CSharpPrimitives.TypeNames)
+			{
+				if (CSharpPrimitives.IsFloatingPoint(channelType) != CSharpPrimitives.IsFloatingPoint(data.ChannelType))
+				{
+					continue;
+				}
+
+				if (channelType == typeof(decimal) || data.ChannelType == typeof(decimal))
+				{
+					continue;
+				}
+
+				if (CSharpPrimitives.Sizes[data.ChannelType] > CSharpPrimitives.Sizes[channelType])
+				{
+					continue;
+				}
+
+				textWriter.WriteLineNoTabs();
+				textWriter.WriteLosslessConversionTest(data.ColorType.Name, data.ChannelTypeName, $"{nameof(ColorRGBA<byte>)}<{channelTypeName}>", channelTypeName);
+
+				if (!data.AlphaChannel)
+				{
+					textWriter.WriteLineNoTabs();
+					textWriter.WriteLosslessConversionTest(data.ColorType.Name, data.ChannelTypeName, $"{nameof(ColorRGB<byte>)}<{channelTypeName}>", channelTypeName);
+					if (!data.BlueChannel)
+					{
+						textWriter.WriteLineNoTabs();
+						textWriter.WriteLosslessConversionTest(data.ColorType.Name, data.ChannelTypeName, $"{nameof(ColorRG<byte>)}<{channelTypeName}>", channelTypeName);
+						if (!data.GreenChannel)
+						{
+							textWriter.WriteLineNoTabs();
+							textWriter.WriteLosslessConversionTest(data.ColorType.Name, data.ChannelTypeName, $"{nameof(ColorR<byte>)}<{channelTypeName}>", channelTypeName);
+						}
+					}
+				}
+				if (!data.RedChannel && !data.GreenChannel && !data.BlueChannel)
+				{
+					textWriter.WriteLineNoTabs();
+					textWriter.WriteLosslessConversionTest(data.ColorType.Name, data.ChannelTypeName, $"{nameof(ColorA<byte>)}<{channelTypeName}>", channelTypeName);
+				}
+			}
+
 			textWriter.Indent--;
 			textWriter.WriteClassDefinitionClose();
 
@@ -66,6 +104,76 @@ internal static class TestClassGenerator
 		}
 	}
 
+	private static void MakeGenericColorTests()
+	{
+		using IndentedTextWriter writer = IndentedTextWriterFactory.Create(OutputFolder, "GenericColorTests");
+		writer.WriteGeneratedCodeWarning();
+		writer.WriteLine();
+		writer.WriteUsing(typeof(ColorR<>).Namespace!);
+		writer.WriteLine();
+		writer.WriteFileScopedNamespace();
+
+		foreach (string channeName in CSharpPrimitives.TypeNames.Values)
+		{
+			foreach (string colorName in GetGenericColorNames())
+			{
+				writer.WriteLine($"[TestFixture(TypeArgs = new Type[] {{ typeof({colorName}<{channeName}>), typeof({channeName}) }})]");
+			}
+		}
+		writer.WriteLine("partial class GenericColorTests<TColor, TChannel>");
+		using (new CurlyBrackets(writer))
+		{
+		}
+	}
+
+	internal static IEnumerable<string> GetGenericColorNames()
+	{
+		yield return nameof(ColorR<byte>);
+		yield return nameof(ColorRG<byte>);
+		yield return nameof(ColorRGB<byte>);
+		yield return nameof(ColorRGBA<byte>);
+		yield return nameof(ColorA<byte>);
+	}
+
+	private static void MakeLosslessColorTests()
+	{
+		using IndentedTextWriter writer = IndentedTextWriterFactory.Create(OutputFolder, "LosslessColorTests");
+		writer.WriteGeneratedCodeWarning();
+		writer.WriteLine();
+		writer.WriteUsing(typeof(ColorR<>).Namespace!);
+		writer.WriteLine();
+		writer.WriteFileScopedNamespace();
+
+		foreach ((Type t1, string t1Name) in CSharpPrimitives.TypeNames)
+		{
+			foreach ((Type t2, string t2Name) in CSharpPrimitives.TypeNames)
+			{
+				if (CSharpPrimitives.IsFloatingPoint(t1) != CSharpPrimitives.IsFloatingPoint(t2))
+				{
+					// one is floating point, the other is not
+					continue;
+				}
+
+				if (t1 == typeof(decimal) || t2 == typeof(decimal))
+				{
+					// decimal has rounding errors when converting to/from double and float
+					continue;
+				}
+
+				if (CSharpPrimitives.Sizes[t1] > CSharpPrimitives.Sizes[t2])
+				{
+					continue;
+				}
+
+				writer.WriteLine($"[TestFixture(TypeArgs = new Type[] {{ typeof({t1Name}), typeof({t2Name}) }})]");
+			}
+		}
+		writer.WriteLine("partial class LosslessColorTests<T1, T2>");
+		using (new CurlyBrackets(writer))
+		{
+		}
+	}
+
 	private static void WriteClassDefinitionClose(this IndentedTextWriter textWriter)
 	{
 		textWriter.WriteLine("}");
@@ -131,7 +239,7 @@ internal static class TestClassGenerator
 		{
 			textWriter.WriteLine($"var {char.ToLowerInvariant(otherChannel)} = color.{otherChannel};");
 		}
-		textWriter.WriteLine($"color.{channel} = {randomValueDictionary[data.ChannelType].SetValue};");
+		textWriter.WriteLine($"color.{channel} = MakeRandomValue();");
 
 		textWriter.WriteLine("Assert.Multiple(() =>");
 		textWriter.WriteLine("{");
@@ -160,44 +268,27 @@ internal static class TestClassGenerator
 
 	private static void WriteLosslessConversionTest(this IndentedTextWriter textWriter, GenerationData currentData, GenerationData containingData)
 	{
-		string currentName = currentData.ColorType.Name;
-		string containingName = containingData.ColorType.Name;
+		textWriter.WriteLosslessConversionTest(currentData.ColorType.Name, currentData.ChannelTypeName, containingData.ColorType.Name, containingData.ChannelTypeName);
+	}
 
-		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("}");
+	private static void WriteLosslessConversionTest(this IndentedTextWriter writer, string t1Color, string t1Channel, string t2Color, string t2Channel)
+	{
+		writer.WriteLine("[Test]");
+		writer.WriteLine($"public void ConversionIsLosslessTo{t2Color.Replace("<","_").Replace(">", "")}()");
+		using (new CurlyBrackets(writer))
+		{
+			writer.WriteLine($"LosslessConversion.Assert<{t1Color}, {t1Channel}, {t2Color}, {t2Channel}>();");
+		}
 	}
 
 	private static void WriteMakeRandomColor(this IndentedTextWriter textWriter, GenerationData data)
 	{
-		textWriter.WriteLine($"public static {data.ColorType.Name} MakeRandomColor()");
-		textWriter.WriteLine("{");
-		textWriter.Indent += 1;
+		textWriter.WriteLine($"public static {data.ColorType.Name} MakeRandomColor() => ColorRandom<{data.ColorType.Name}, {data.ChannelTypeName}>.MakeRandomColor();");
+	}
 
-		textWriter.WriteLine("return new()");
-		textWriter.WriteLine("{");
-		textWriter.Indent += 1;
-
-		ColorRandomValues randomValues = randomValueDictionary[data.ChannelType];
-		textWriter.WriteLine($"R = {randomValues.DefaultR},");
-		textWriter.WriteLine($"G = {randomValues.DefaultG},");
-		textWriter.WriteLine($"B = {randomValues.DefaultB},");
-		textWriter.WriteLine($"A = {randomValues.DefaultA},");
-
-		textWriter.Indent -= 1;
-		textWriter.WriteLine("};");
-
-		textWriter.Indent -= 1;
-		textWriter.WriteLine("}");
+	private static void WriteMakeRandomValue(this IndentedTextWriter textWriter, GenerationData data)
+	{
+		textWriter.WriteLine($"public static {data.ChannelTypeName} MakeRandomValue() => ColorRandom<{data.ColorType.Name}, {data.ChannelTypeName}>.MakeRandomValue();");
 	}
 
 	private static void WriteMethodSymmetryTest(this IndentedTextWriter textWriter)
@@ -226,10 +317,9 @@ internal static class TestClassGenerator
 		textWriter.WriteLine("}");
 	}
 
-	private static void WriteNamespaceUsings(this IndentedTextWriter textWriter, GenerationData data)
+	private static void WriteNamespaceUsings(this IndentedTextWriter textWriter, string? colorNamespace)
 	{
-		textWriter.WriteLine($"using {typeof(ColorExtensions).Namespace};");
-		textWriter.WriteLine($"using {data.ColorType.Namespace};");
+		textWriter.WriteLine($"using {colorNamespace};");
 		textWriter.WriteLine($"using {typeof(System.Runtime.CompilerServices.Unsafe).Namespace};");
 		textWriter.WriteLine();//An empty line after the usings
 	}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorA8Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorA8Tests.g.cs
deleted file mode 100644
index 0bf1fd4..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorA8Tests.g.cs
+++ /dev/null
@@ -1,219 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorA8Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorA8>(), Is.EqualTo(1));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorA8 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.g.cs
index cc09ba6..19b496b 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorARGB16Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorARGB16>(), Is.EqualTo(2));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorARGB16Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0b01001110;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorARGB16Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0b01001110;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorARGB16Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0b01001110;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorARGB16Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0b01001110;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorARGB16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,69 +141,68 @@ public partial class ColorARGB16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorARGB16 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			A = 0b11000111,
-		};
-	}
-	
+
+	public static ColorARGB16 MakeRandomColor() => ColorRandom<ColorARGB16, byte>.MakeRandomColor();
+
+	public static byte MakeRandomValue() => ColorRandom<ColorARGB16, byte>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorARGB32IsLossless()
+	public void ConversionIsLosslessToColorARGB32()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorARGB32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorBGRA32IsLossless()
+	public void ConversionIsLosslessToColorBGRA32()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorBGRA32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32IsLossless()
+	public void ConversionIsLosslessToColorRGBA_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64IsLossless()
+	public void ConversionIsLosslessToColorRGBA_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<ushort>, ushort>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_int()
+	{
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_uint()
+	{
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_long()
+	{
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_ulong()
+	{
+		LosslessConversion.Assert<ColorARGB16, byte, ColorRGBA<ulong>, ulong>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.g.cs
index 512ff56..ea86c86 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorARGB32Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorARGB32>(), Is.EqualTo(4));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorARGB32Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0b01001110;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorARGB32Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0b01001110;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorARGB32Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0b01001110;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorARGB32Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0b01001110;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorARGB32Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,69 +141,68 @@ public partial class ColorARGB32Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorARGB32 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			A = 0b11000111,
-		};
-	}
-	
+
+	public static ColorARGB32 MakeRandomColor() => ColorRandom<ColorARGB32, byte>.MakeRandomColor();
+
+	public static byte MakeRandomValue() => ColorRandom<ColorARGB32, byte>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorARGB32IsLossless()
+	public void ConversionIsLosslessToColorARGB32()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorARGB32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorBGRA32IsLossless()
+	public void ConversionIsLosslessToColorBGRA32()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorBGRA32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32IsLossless()
+	public void ConversionIsLosslessToColorRGBA_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64IsLossless()
+	public void ConversionIsLosslessToColorRGBA_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<ushort>, ushort>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_int()
+	{
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_uint()
+	{
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_long()
+	{
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_ulong()
+	{
+		LosslessConversion.Assert<ColorARGB32, byte, ColorRGBA<ulong>, ulong>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorBGRA32Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorBGRA32Tests.g.cs
index 43ad5ed..0a4adbf 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorBGRA32Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorBGRA32Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorBGRA32Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorBGRA32>(), Is.EqualTo(4));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorBGRA32Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0b01001110;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorBGRA32Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0b01001110;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorBGRA32Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0b01001110;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorBGRA32Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0b01001110;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorBGRA32Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,69 +141,68 @@ public partial class ColorBGRA32Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorBGRA32 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			A = 0b11000111,
-		};
-	}
-	
+
+	public static ColorBGRA32 MakeRandomColor() => ColorRandom<ColorBGRA32, byte>.MakeRandomColor();
+
+	public static byte MakeRandomValue() => ColorRandom<ColorBGRA32, byte>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorARGB32IsLossless()
+	public void ConversionIsLosslessToColorARGB32()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorARGB32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorBGRA32IsLossless()
+	public void ConversionIsLosslessToColorBGRA32()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorBGRA32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32IsLossless()
+	public void ConversionIsLosslessToColorRGBA_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64IsLossless()
+	public void ConversionIsLosslessToColorRGBA_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<ushort>, ushort>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_int()
+	{
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_uint()
+	{
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_long()
+	{
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_ulong()
+	{
+		LosslessConversion.Assert<ColorBGRA32, byte, ColorRGBA<ulong>, ulong>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16HalfTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR16HalfTests.g.cs
deleted file mode 100644
index 6f62ef2..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16HalfTests.g.cs
+++ /dev/null
@@ -1,264 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR16HalfTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR16Half>(), Is.EqualTo(2));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR16Half MakeRandomColor()
-	{
-		return new()
-		{
-			R = (Half)0.447f,
-			G = (Half)0.224f,
-			B = (Half)0.95f,
-			A = (Half)0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorR16HalfIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorR16Half converted = original.Convert<ColorR16Half, Half, ColorR16Half, Half>();
-		ColorR16Half convertedBack = converted.Convert<ColorR16Half, Half, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorR32SingleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorR32Single converted = original.Convert<ColorR16Half, Half, ColorR32Single, float>();
-		ColorR16Half convertedBack = converted.Convert<ColorR32Single, float, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorR64DoubleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorR64Double converted = original.Convert<ColorR16Half, Half, ColorR64Double, double>();
-		ColorR16Half convertedBack = converted.Convert<ColorR64Double, double, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG32HalfIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRG32Half converted = original.Convert<ColorR16Half, Half, ColorRG32Half, Half>();
-		ColorR16Half convertedBack = converted.Convert<ColorRG32Half, Half, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG64SingleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRG64Single converted = original.Convert<ColorR16Half, Half, ColorRG64Single, float>();
-		ColorR16Half convertedBack = converted.Convert<ColorRG64Single, float, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorR16Half, Half, ColorRG128Double, double>();
-		ColorR16Half convertedBack = converted.Convert<ColorRG128Double, double, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB48HalfIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGB48Half converted = original.Convert<ColorR16Half, Half, ColorRGB48Half, Half>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGB48Half, Half, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorR16Half, Half, ColorRGB96Single, float>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGB96Single, float, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorR16Half, Half, ColorRGB192Double, double>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGB192Double, double, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorR16Half, Half, ColorRGBA128Single, float>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGBA128Single, float, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorR16Half, Half, ColorRGBA256Double, double>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGBA256Double, double, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA64HalfIsLossless()
-	{
-		ColorR16Half original = MakeRandomColor();
-		ColorRGBA64Half converted = original.Convert<ColorR16Half, Half, ColorRGBA64Half, Half>();
-		ColorR16Half convertedBack = converted.Convert<ColorRGBA64Half, Half, ColorR16Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR16SignedTests.g.cs
deleted file mode 100644
index aaf9c64..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16SignedTests.g.cs
+++ /dev/null
@@ -1,228 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR16SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR16Signed>(), Is.EqualTo(2));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR16Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -24000,
-			G = 21354,
-			B = -80,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR16Tests.g.cs
deleted file mode 100644
index b63e1c7..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR16Tests.g.cs
+++ /dev/null
@@ -1,228 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR16Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR16>(), Is.EqualTo(2));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR16 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 44000,
-			G = 21354,
-			B = 60080,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR32SingleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR32SingleTests.g.cs
deleted file mode 100644
index a9248b0..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR32SingleTests.g.cs
+++ /dev/null
@@ -1,228 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR32SingleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR32Single>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR32Single MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447f,
-			G = 0.224f,
-			B = 0.95f,
-			A = 0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorR32SingleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorR32Single converted = original.Convert<ColorR32Single, float, ColorR32Single, float>();
-		ColorR32Single convertedBack = converted.Convert<ColorR32Single, float, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorR64DoubleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorR64Double converted = original.Convert<ColorR32Single, float, ColorR64Double, double>();
-		ColorR32Single convertedBack = converted.Convert<ColorR64Double, double, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG64SingleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRG64Single converted = original.Convert<ColorR32Single, float, ColorRG64Single, float>();
-		ColorR32Single convertedBack = converted.Convert<ColorRG64Single, float, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorR32Single, float, ColorRG128Double, double>();
-		ColorR32Single convertedBack = converted.Convert<ColorRG128Double, double, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorR32Single, float, ColorRGB96Single, float>();
-		ColorR32Single convertedBack = converted.Convert<ColorRGB96Single, float, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorR32Single, float, ColorRGB192Double, double>();
-		ColorR32Single convertedBack = converted.Convert<ColorRGB192Double, double, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorR32Single, float, ColorRGBA128Single, float>();
-		ColorR32Single convertedBack = converted.Convert<ColorRGBA128Single, float, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorR32Single original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorR32Single, float, ColorRGBA256Double, double>();
-		ColorR32Single convertedBack = converted.Convert<ColorRGBA256Double, double, ColorR32Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR64DoubleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR64DoubleTests.g.cs
deleted file mode 100644
index 5d7bc41..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR64DoubleTests.g.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR64DoubleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR64Double>(), Is.EqualTo(8));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR64Double MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447,
-			G = 0.224,
-			B = 0.95,
-			A = 0.897,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorR64DoubleIsLossless()
-	{
-		ColorR64Double original = MakeRandomColor();
-		ColorR64Double converted = original.Convert<ColorR64Double, double, ColorR64Double, double>();
-		ColorR64Double convertedBack = converted.Convert<ColorR64Double, double, ColorR64Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorR64Double original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorR64Double, double, ColorRG128Double, double>();
-		ColorR64Double convertedBack = converted.Convert<ColorRG128Double, double, ColorR64Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorR64Double original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorR64Double, double, ColorRGB192Double, double>();
-		ColorR64Double convertedBack = converted.Convert<ColorRGB192Double, double, ColorR64Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorR64Double original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorR64Double, double, ColorRGBA256Double, double>();
-		ColorR64Double convertedBack = converted.Convert<ColorRGBA256Double, double, ColorR64Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR8SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR8SignedTests.g.cs
deleted file mode 100644
index d79736a..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR8SignedTests.g.cs
+++ /dev/null
@@ -1,318 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR8SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR8Signed>(), Is.EqualTo(1));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR8Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -0b01010101,
-			G = 0b01110010,
-			B = -0b00001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorR8Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorR8Tests.g.cs
deleted file mode 100644
index 3506ac8..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorR8Tests.g.cs
+++ /dev/null
@@ -1,318 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorR8Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorR8>(), Is.EqualTo(1));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorR8 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG128DoubleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG128DoubleTests.g.cs
deleted file mode 100644
index 0e5457b..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG128DoubleTests.g.cs
+++ /dev/null
@@ -1,183 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG128DoubleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG128Double>(), Is.EqualTo(16));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG128Double MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447,
-			G = 0.224,
-			B = 0.95,
-			A = 0.897,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorRG128Double original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorRG128Double, double, ColorRG128Double, double>();
-		ColorRG128Double convertedBack = converted.Convert<ColorRG128Double, double, ColorRG128Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRG128Double original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRG128Double, double, ColorRGB192Double, double>();
-		ColorRG128Double convertedBack = converted.Convert<ColorRGB192Double, double, ColorRG128Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRG128Double original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRG128Double, double, ColorRGBA256Double, double>();
-		ColorRG128Double convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRG128Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16SignedTests.g.cs
deleted file mode 100644
index 57fa4bc..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16SignedTests.g.cs
+++ /dev/null
@@ -1,282 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG16SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG16Signed>(), Is.EqualTo(2));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG16Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -0b01010101,
-			G = 0b01110010,
-			B = -0b00001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16Tests.g.cs
deleted file mode 100644
index dffa98b..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG16Tests.g.cs
+++ /dev/null
@@ -1,282 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG16Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG16>(), Is.EqualTo(2));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG16 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32HalfTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32HalfTests.g.cs
deleted file mode 100644
index b66151c..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32HalfTests.g.cs
+++ /dev/null
@@ -1,237 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG32HalfTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG32Half>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG32Half MakeRandomColor()
-	{
-		return new()
-		{
-			R = (Half)0.447f,
-			G = (Half)0.224f,
-			B = (Half)0.95f,
-			A = (Half)0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRG32HalfIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRG32Half converted = original.Convert<ColorRG32Half, Half, ColorRG32Half, Half>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRG32Half, Half, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG64SingleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRG64Single converted = original.Convert<ColorRG32Half, Half, ColorRG64Single, float>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRG64Single, float, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorRG32Half, Half, ColorRG128Double, double>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRG128Double, double, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB48HalfIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGB48Half converted = original.Convert<ColorRG32Half, Half, ColorRGB48Half, Half>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGB48Half, Half, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorRG32Half, Half, ColorRGB96Single, float>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGB96Single, float, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRG32Half, Half, ColorRGB192Double, double>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGB192Double, double, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRG32Half, Half, ColorRGBA128Single, float>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRG32Half, Half, ColorRGBA256Double, double>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA64HalfIsLossless()
-	{
-		ColorRG32Half original = MakeRandomColor();
-		ColorRGBA64Half converted = original.Convert<ColorRG32Half, Half, ColorRGBA64Half, Half>();
-		ColorRG32Half convertedBack = converted.Convert<ColorRGBA64Half, Half, ColorRG32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32SignedTests.g.cs
deleted file mode 100644
index 0cbf9f9..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32SignedTests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG32SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG32Signed>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG32Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -24000,
-			G = 21354,
-			B = -80,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32Tests.g.cs
deleted file mode 100644
index 2df61f3..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG32Tests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG32Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG32>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG32 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 44000,
-			G = 21354,
-			B = 60080,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG64SingleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRG64SingleTests.g.cs
deleted file mode 100644
index b7e8813..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRG64SingleTests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRG64SingleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRG64Single>(), Is.EqualTo(8));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRG64Single MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447f,
-			G = 0.224f,
-			B = 0.95f,
-			A = 0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRG64SingleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRG64Single converted = original.Convert<ColorRG64Single, float, ColorRG64Single, float>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRG64Single, float, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRG128DoubleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRG128Double converted = original.Convert<ColorRG64Single, float, ColorRG128Double, double>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRG128Double, double, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorRG64Single, float, ColorRGB96Single, float>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRGB96Single, float, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRG64Single, float, ColorRGB192Double, double>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRGB192Double, double, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRG64Single, float, ColorRGBA128Single, float>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRG64Single original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRG64Single, float, ColorRGBA256Double, double>();
-		ColorRG64Single convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRG64Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.g.cs
index 43ca80d..cedb9b9 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorRGB16Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorRGB16>(), Is.EqualTo(2));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorRGB16Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0b01001110;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorRGB16Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0b01001110;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorRGB16Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0b01001110;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorRGB16Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0b01001110;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorRGB16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,105 +141,116 @@ public partial class ColorRGB16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorRGB16 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			A = 0b11000111,
-		};
-	}
-	
+
+	public static ColorRGB16 MakeRandomColor() => ColorRandom<ColorRGB16, byte>.MakeRandomColor();
+
+	public static byte MakeRandomValue() => ColorRandom<ColorRGB16, byte>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorARGB32IsLossless()
+	public void ConversionIsLosslessToColorARGB32()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorARGB32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorBGRA32IsLossless()
+	public void ConversionIsLosslessToColorBGRA32()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorBGRA32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB24IsLossless()
+	public void ConversionIsLosslessToColorRGBA_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB24SignedIsLossless()
+	public void ConversionIsLosslessToColorRGB_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB48IsLossless()
+	public void ConversionIsLosslessToColorRGBA_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB48SignedIsLossless()
+	public void ConversionIsLosslessToColorRGB_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32IsLossless()
+	public void ConversionIsLosslessToColorRGBA_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32SignedIsLossless()
+	public void ConversionIsLosslessToColorRGB_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64IsLossless()
+	public void ConversionIsLosslessToColorRGBA_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<ushort>, ushort>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64SignedIsLossless()
+	public void ConversionIsLosslessToColorRGB_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<ushort>, ushort>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_int()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGB_int()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_uint()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGB_uint()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_long()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGB_long()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_ulong()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGBA<ulong>, ulong>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGB_ulong()
+	{
+		LosslessConversion.Assert<ColorRGB16, byte, ColorRGB<ulong>, ulong>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB192DoubleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB192DoubleTests.g.cs
deleted file mode 100644
index 1ae886c..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB192DoubleTests.g.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB192DoubleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB192Double>(), Is.EqualTo(24));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB192Double MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447,
-			G = 0.224,
-			B = 0.95,
-			A = 0.897,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRGB192Double original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRGB192Double, double, ColorRGB192Double, double>();
-		ColorRGB192Double convertedBack = converted.Convert<ColorRGB192Double, double, ColorRGB192Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGB192Double original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGB192Double, double, ColorRGBA256Double, double>();
-		ColorRGB192Double convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGB192Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24SignedTests.g.cs
deleted file mode 100644
index 76ce63b..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24SignedTests.g.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB24SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB24Signed>(), Is.EqualTo(3));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB24Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -0b01010101,
-			G = 0b01110010,
-			B = -0b00001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24Tests.g.cs
deleted file mode 100644
index d372eda..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24Tests.g.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB24Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB24>(), Is.EqualTo(3));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB24 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.cs
new file mode 100644
index 0000000..992e7db
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.cs
@@ -0,0 +1,21 @@
+using AssetRipper.TextureDecoder.Rgb.Formats;
+using System.Runtime.CompilerServices;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+
+[Ignore($"Ignore. Bugs in {nameof(ColorRGB32Half)}")]
+public partial class ColorRGB32HalfTests
+{
+	[Test]
+	public void MaxValueIsOne()
+	{
+		Assert.Multiple(() =>
+		{
+			ColorRGB32Half color = Unsafe.As<uint, ColorRGB32Half>(ref Unsafe.AsRef(uint.MaxValue));
+			Assert.That(color.R, Is.EqualTo(Half.One), "R");
+			Assert.That(color.G, Is.EqualTo(Half.One), "G");
+			Assert.That(color.B, Is.EqualTo(Half.One), "B");
+			Assert.That(color.A, Is.EqualTo(Half.One), "A");
+		});
+	}
+}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.g.cs
index 6b9e2c4..4023c80 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB32HalfTests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorRGB32HalfTests
 	{
 		Assert.That(Unsafe.SizeOf<ColorRGB32Half>(), Is.EqualTo(4));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorRGB32HalfTests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = (Half)0.333f;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorRGB32HalfTests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = (Half)0.333f;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorRGB32HalfTests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = (Half)0.333f;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorRGB32HalfTests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = (Half)0.333f;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorRGB32HalfTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,69 +141,44 @@ public partial class ColorRGB32HalfTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorRGB32Half MakeRandomColor()
-	{
-		return new()
-		{
-			R = (Half)0.447f,
-			G = (Half)0.224f,
-			B = (Half)0.95f,
-			A = (Half)0.897f,
-		};
-	}
-	
+
+	public static ColorRGB32Half MakeRandomColor() => ColorRandom<ColorRGB32Half, Half>.MakeRandomColor();
+
+	public static Half MakeRandomValue() => ColorRandom<ColorRGB32Half, Half>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorRGB48HalfIsLossless()
+	public void ConversionIsLosslessToColorRGBA_Half()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGB48Half converted = original.Convert<ColorRGB32Half, Half, ColorRGB48Half, Half>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGB48Half, Half, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGBA<Half>, Half>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
+	public void ConversionIsLosslessToColorRGB_Half()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorRGB32Half, Half, ColorRGB96Single, float>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGB96Single, float, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGB<Half>, Half>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
+	public void ConversionIsLosslessToColorRGBA_float()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRGB32Half, Half, ColorRGB192Double, double>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGB192Double, double, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGBA<float>, float>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
+	public void ConversionIsLosslessToColorRGB_float()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRGB32Half, Half, ColorRGBA128Single, float>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGB<float>, float>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
+	public void ConversionIsLosslessToColorRGBA_double()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGB32Half, Half, ColorRGBA256Double, double>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGBA<double>, double>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64HalfIsLossless()
+	public void ConversionIsLosslessToColorRGB_double()
 	{
-		ColorRGB32Half original = MakeRandomColor();
-		ColorRGBA64Half converted = original.Convert<ColorRGB32Half, Half, ColorRGBA64Half, Half>();
-		ColorRGB32Half convertedBack = converted.Convert<ColorRGBA64Half, Half, ColorRGB32Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB32Half, Half, ColorRGB<double>, double>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48HalfTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48HalfTests.g.cs
deleted file mode 100644
index 72339e5..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48HalfTests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB48HalfTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB48Half>(), Is.EqualTo(6));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB48Half MakeRandomColor()
-	{
-		return new()
-		{
-			R = (Half)0.447f,
-			G = (Half)0.224f,
-			B = (Half)0.95f,
-			A = (Half)0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGB48HalfIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGB48Half converted = original.Convert<ColorRGB48Half, Half, ColorRGB48Half, Half>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGB48Half, Half, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorRGB48Half, Half, ColorRGB96Single, float>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGB96Single, float, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRGB48Half, Half, ColorRGB192Double, double>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGB192Double, double, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRGB48Half, Half, ColorRGBA128Single, float>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGB48Half, Half, ColorRGBA256Double, double>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA64HalfIsLossless()
-	{
-		ColorRGB48Half original = MakeRandomColor();
-		ColorRGBA64Half converted = original.Convert<ColorRGB48Half, Half, ColorRGBA64Half, Half>();
-		ColorRGB48Half convertedBack = converted.Convert<ColorRGBA64Half, Half, ColorRGB48Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48SignedTests.g.cs
deleted file mode 100644
index 7adb022..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48SignedTests.g.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB48SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB48Signed>(), Is.EqualTo(6));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB48Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -24000,
-			G = 21354,
-			B = -80,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48Tests.g.cs
deleted file mode 100644
index f45fb60..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48Tests.g.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB48Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB48>(), Is.EqualTo(6));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB48 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 44000,
-			G = 21354,
-			B = 60080,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB96SingleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB96SingleTests.g.cs
deleted file mode 100644
index 2f90ccb..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB96SingleTests.g.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGB96SingleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGB96Single>(), Is.EqualTo(12));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGB96Single MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447f,
-			G = 0.224f,
-			B = 0.95f,
-			A = 0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGB96SingleIsLossless()
-	{
-		ColorRGB96Single original = MakeRandomColor();
-		ColorRGB96Single converted = original.Convert<ColorRGB96Single, float, ColorRGB96Single, float>();
-		ColorRGB96Single convertedBack = converted.Convert<ColorRGB96Single, float, ColorRGB96Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
-	{
-		ColorRGB96Single original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRGB96Single, float, ColorRGB192Double, double>();
-		ColorRGB96Single convertedBack = converted.Convert<ColorRGB192Double, double, ColorRGB96Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRGB96Single original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRGB96Single, float, ColorRGBA128Single, float>();
-		ColorRGB96Single convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRGB96Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGB96Single original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGB96Single, float, ColorRGBA256Double, double>();
-		ColorRGB96Single convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGB96Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.g.cs
index 9344d3d..23eba63 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorRGB9e5Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorRGB9e5>(), Is.EqualTo(4));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorRGB9e5Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0.333;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorRGB9e5Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0.333;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorRGB9e5Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0.333;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorRGB9e5Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0.333;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorRGB9e5Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,33 +141,20 @@ public partial class ColorRGB9e5Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorRGB9e5 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447,
-			G = 0.224,
-			B = 0.95,
-			A = 0.897,
-		};
-	}
-	
+
+	public static ColorRGB9e5 MakeRandomColor() => ColorRandom<ColorRGB9e5, double>.MakeRandomColor();
+
+	public static double MakeRandomValue() => ColorRandom<ColorRGB9e5, double>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorRGB192DoubleIsLossless()
+	public void ConversionIsLosslessToColorRGBA_double()
 	{
-		ColorRGB9e5 original = MakeRandomColor();
-		ColorRGB192Double converted = original.Convert<ColorRGB9e5, double, ColorRGB192Double, double>();
-		ColorRGB9e5 convertedBack = converted.Convert<ColorRGB192Double, double, ColorRGB9e5, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB9e5, double, ColorRGBA<double>, double>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
+	public void ConversionIsLosslessToColorRGB_double()
 	{
-		ColorRGB9e5 original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGB9e5, double, ColorRGBA256Double, double>();
-		ColorRGB9e5 convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGB9e5, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
+		LosslessConversion.Assert<ColorRGB9e5, double, ColorRGB<double>, double>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA128SingleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA128SingleTests.g.cs
deleted file mode 100644
index f197e6e..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA128SingleTests.g.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA128SingleTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA128Single>(), Is.EqualTo(16));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA128Single MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447f,
-			G = 0.224f,
-			B = 0.95f,
-			A = 0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRGBA128Single original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRGBA128Single, float, ColorRGBA128Single, float>();
-		ColorRGBA128Single convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRGBA128Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGBA128Single original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGBA128Single, float, ColorRGBA256Double, double>();
-		ColorRGBA128Single convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGBA128Single, float>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.g.cs
index 1b2094e..e2d67b9 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.g.cs
@@ -1,6 +1,5 @@
-//This code is source generated. Do not edit manually.
+// Auto-generated code. Do not modify manually.
 
-using AssetRipper.TextureDecoder.Rgb;
 using AssetRipper.TextureDecoder.Rgb.Formats;
 using System.Runtime.CompilerServices;
 
@@ -13,7 +12,7 @@ public partial class ColorRGBA16Tests
 	{
 		Assert.That(Unsafe.SizeOf<ColorRGBA16>(), Is.EqualTo(2));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
@@ -57,7 +56,7 @@ public partial class ColorRGBA16Tests
 		var g = color.G;
 		var b = color.B;
 		var a = color.A;
-		color.R = 0b01001110;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -73,7 +72,7 @@ public partial class ColorRGBA16Tests
 		var r = color.R;
 		var b = color.B;
 		var a = color.A;
-		color.G = 0b01001110;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -89,7 +88,7 @@ public partial class ColorRGBA16Tests
 		var r = color.R;
 		var g = color.G;
 		var a = color.A;
-		color.B = 0b01001110;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -105,7 +104,7 @@ public partial class ColorRGBA16Tests
 		var r = color.R;
 		var g = color.G;
 		var b = color.B;
-		color.A = 0b01001110;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,7 +126,7 @@ public partial class ColorRGBA16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
@@ -142,69 +141,68 @@ public partial class ColorRGBA16Tests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorRGBA16 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			A = 0b11000111,
-		};
-	}
-	
+
+	public static ColorRGBA16 MakeRandomColor() => ColorRandom<ColorRGBA16, byte>.MakeRandomColor();
+
+	public static byte MakeRandomValue() => ColorRandom<ColorRGBA16, byte>.MakeRandomValue();
+
 	[Test]
-	public void ConversionToColorARGB32IsLossless()
+	public void ConversionIsLosslessToColorARGB32()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorARGB32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorBGRA32IsLossless()
+	public void ConversionIsLosslessToColorBGRA32()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorBGRA32, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32IsLossless()
+	public void ConversionIsLosslessToColorRGBA_sbyte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<sbyte>, sbyte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA32SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_byte()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<byte>, byte>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64IsLossless()
+	public void ConversionIsLosslessToColorRGBA_short()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<short>, short>();
 	}
-	
+
 	[Test]
-	public void ConversionToColorRGBA64SignedIsLossless()
+	public void ConversionIsLosslessToColorRGBA_ushort()
 	{
-		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));
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<ushort>, ushort>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_int()
+	{
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<int>, int>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_uint()
+	{
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<uint>, uint>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_long()
+	{
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<long>, long>();
+	}
+
+	[Test]
+	public void ConversionIsLosslessToColorRGBA_ulong()
+	{
+		LosslessConversion.Assert<ColorRGBA16, byte, ColorRGBA<ulong>, ulong>();
 	}
 }
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32SignedTests.g.cs
deleted file mode 100644
index 08fba76..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32SignedTests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA32SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA32Signed>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA32Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -0b01010101,
-			G = 0b01110010,
-			B = -0b00001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32Tests.g.cs
deleted file mode 100644
index 7bdf66b..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32Tests.g.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA32Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA32>(), Is.EqualTo(4));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0b01001110;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA32 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0b11010101,
-			G = 0b01110010,
-			B = 0b10001111,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64HalfTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64HalfTests.g.cs
deleted file mode 100644
index 8be6ca2..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64HalfTests.g.cs
+++ /dev/null
@@ -1,183 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA64HalfTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA64Half>(), Is.EqualTo(8));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = (Half)0.333f;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA64Half MakeRandomColor()
-	{
-		return new()
-		{
-			R = (Half)0.447f,
-			G = (Half)0.224f,
-			B = (Half)0.95f,
-			A = (Half)0.897f,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA128SingleIsLossless()
-	{
-		ColorRGBA64Half original = MakeRandomColor();
-		ColorRGBA128Single converted = original.Convert<ColorRGBA64Half, Half, ColorRGBA128Single, float>();
-		ColorRGBA64Half convertedBack = converted.Convert<ColorRGBA128Single, float, ColorRGBA64Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGBA64Half original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGBA64Half, Half, ColorRGBA256Double, double>();
-		ColorRGBA64Half convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGBA64Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA64HalfIsLossless()
-	{
-		ColorRGBA64Half original = MakeRandomColor();
-		ColorRGBA64Half converted = original.Convert<ColorRGBA64Half, Half, ColorRGBA64Half, Half>();
-		ColorRGBA64Half convertedBack = converted.Convert<ColorRGBA64Half, Half, ColorRGBA64Half, Half>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64SignedTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64SignedTests.g.cs
deleted file mode 100644
index 5699cd8..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64SignedTests.g.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA64SignedTests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA64Signed>(), Is.EqualTo(8));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 31871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA64Signed MakeRandomColor()
-	{
-		return new()
-		{
-			R = -24000,
-			G = 21354,
-			B = -80,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64Tests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64Tests.g.cs
deleted file mode 100644
index 44201aa..0000000
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64Tests.g.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
-using System.Runtime.CompilerServices;
-
-namespace AssetRipper.TextureDecoder.Tests.Formats;
-
-public partial class ColorRGBA64Tests
-{
-	[Test]
-	public void CorrectSizeTest()
-	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA64>(), Is.EqualTo(8));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_R()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		color.R = r;
-		Assert.That(color.R, Is.EqualTo(r));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_G()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		color.G = g;
-		Assert.That(color.G, Is.EqualTo(g));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_B()
-	{
-		var color = MakeRandomColor();
-		var b = color.B;
-		color.B = b;
-		Assert.That(color.B, Is.EqualTo(b));
-	}
-	
-	[Test]
-	public void PropertyIsSymmetric_A()
-	{
-		var color = MakeRandomColor();
-		var a = color.A;
-		color.A = a;
-		Assert.That(color.A, Is.EqualTo(a));
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_R()
-	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_G()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_B()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void ChannelsAreIndependent_A()
-	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 33871;
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-		});
-	}
-	
-	[Test]
-	public void GetMethodMatchesProperties()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	[Test]
-	public void MethodsAreSymmetric()
-	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
-		color.SetChannels(r, g, b, a);
-		Assert.Multiple(() =>
-		{
-			Assert.That(color.R, Is.EqualTo(r));
-			Assert.That(color.G, Is.EqualTo(g));
-			Assert.That(color.B, Is.EqualTo(b));
-			Assert.That(color.A, Is.EqualTo(a));
-		});
-	}
-	
-	public static ColorRGBA64 MakeRandomColor()
-	{
-		return new()
-		{
-			R = 44000,
-			G = 21354,
-			B = 60080,
-			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));
-	}
-}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRandom.cs b/AssetRipper.TextureDecoder.Tests/Formats/ColorRandom.cs
new file mode 100644
index 0000000..a2cc8ec
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/ColorRandom.cs
@@ -0,0 +1,18 @@
+using AssetRipper.TextureDecoder.Rgb;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+internal static class ColorRandom<TColor, TChannel> where TColor : unmanaged, IColor<TChannel> where TChannel : unmanaged
+{
+	public static TChannel MakeRandomValue()
+	{
+		ulong value = TestContext.CurrentContext.Random.NextULong();
+		return NumericConversion.Convert<ulong, TChannel>(value);
+	}
+
+	public static TColor MakeRandomColor()
+	{
+		TColor color = default;
+		color.SetChannels(MakeRandomValue(), MakeRandomValue(), MakeRandomValue(), MakeRandomValue());
+		return color;
+	}
+}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA256DoubleTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.cs
similarity index 53%
rename from AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA256DoubleTests.g.cs
rename to AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.cs
index ffe7d5e..9e62708 100644
--- a/AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA256DoubleTests.g.cs
+++ b/AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.cs
@@ -1,63 +1,61 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Rgb;
-using AssetRipper.TextureDecoder.Rgb.Formats;
+using AssetRipper.TextureDecoder.Rgb;
 using System.Runtime.CompilerServices;
 
 namespace AssetRipper.TextureDecoder.Tests.Formats;
 
-public partial class ColorRGBA256DoubleTests
+internal partial class GenericColorTests<TColor, TChannel> where TColor : unmanaged, IColor<TChannel> where TChannel : unmanaged
 {
 	[Test]
 	public void CorrectSizeTest()
 	{
-		Assert.That(Unsafe.SizeOf<ColorRGBA256Double>(), Is.EqualTo(32));
+		int numChannels = (TColor.HasRedChannel ? 1 : 0) + (TColor.HasGreenChannel ? 1 : 0) + (TColor.HasBlueChannel ? 1 : 0) + (TColor.HasAlphaChannel ? 1 : 0);
+		Assert.That(Unsafe.SizeOf<TColor>(), Is.EqualTo(numChannels * Unsafe.SizeOf<TChannel>()));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_R()
 	{
-		var color = MakeRandomColor();
-		var r = color.R;
+		TColor color = MakeRandomColor();
+		TChannel r = color.R;
 		color.R = r;
 		Assert.That(color.R, Is.EqualTo(r));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_G()
 	{
-		var color = MakeRandomColor();
-		var g = color.G;
+		TColor color = MakeRandomColor();
+		TChannel g = color.G;
 		color.G = g;
 		Assert.That(color.G, Is.EqualTo(g));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_B()
 	{
-		var color = MakeRandomColor();
-		var b = color.B;
+		TColor color = MakeRandomColor();
+		TChannel b = color.B;
 		color.B = b;
 		Assert.That(color.B, Is.EqualTo(b));
 	}
-	
+
 	[Test]
 	public void PropertyIsSymmetric_A()
 	{
-		var color = MakeRandomColor();
-		var a = color.A;
+		TColor color = MakeRandomColor();
+		TChannel a = color.A;
 		color.A = a;
 		Assert.That(color.A, Is.EqualTo(a));
 	}
-	
+
 	[Test]
 	public void ChannelsAreIndependent_R()
 	{
-		var color = MakeRandomColor();
-		var g = color.G;
-		var b = color.B;
-		var a = color.A;
-		color.R = 0.333;
+		TColor color = MakeRandomColor();
+		TChannel g = color.G;
+		TChannel b = color.B;
+		TChannel a = color.A;
+		color.R = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.G, Is.EqualTo(g));
@@ -65,15 +63,15 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void ChannelsAreIndependent_G()
 	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var b = color.B;
-		var a = color.A;
-		color.G = 0.333;
+		TColor color = MakeRandomColor();
+		TChannel r = color.R;
+		TChannel b = color.B;
+		TChannel a = color.A;
+		color.G = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -81,15 +79,15 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void ChannelsAreIndependent_B()
 	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var a = color.A;
-		color.B = 0.333;
+		TColor color = MakeRandomColor();
+		TChannel r = color.R;
+		TChannel g = color.G;
+		TChannel a = color.A;
+		color.B = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -97,15 +95,15 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void ChannelsAreIndependent_A()
 	{
-		var color = MakeRandomColor();
-		var r = color.R;
-		var g = color.G;
-		var b = color.B;
-		color.A = 0.333;
+		TColor color = MakeRandomColor();
+		TChannel r = color.R;
+		TChannel g = color.G;
+		TChannel b = color.B;
+		color.A = MakeRandomValue();
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -113,12 +111,12 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.B, Is.EqualTo(b));
 		});
 	}
-	
+
 	[Test]
 	public void GetMethodMatchesProperties()
 	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
+		TColor color = MakeRandomColor();
+		color.GetChannels(out TChannel r, out TChannel g, out TChannel b, out TChannel a);
 		Assert.Multiple(() =>
 		{
 			Assert.That(color.R, Is.EqualTo(r));
@@ -127,12 +125,12 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
+
 	[Test]
 	public void MethodsAreSymmetric()
 	{
-		var color = MakeRandomColor();
-		color.GetChannels(out var r, out var g, out var b, out var a);
+		TColor color = MakeRandomColor();
+		color.GetChannels(out TChannel r, out TChannel g, out TChannel b, out TChannel a);
 		color.SetChannels(r, g, b, a);
 		Assert.Multiple(() =>
 		{
@@ -142,24 +140,8 @@ public partial class ColorRGBA256DoubleTests
 			Assert.That(color.A, Is.EqualTo(a));
 		});
 	}
-	
-	public static ColorRGBA256Double MakeRandomColor()
-	{
-		return new()
-		{
-			R = 0.447,
-			G = 0.224,
-			B = 0.95,
-			A = 0.897,
-		};
-	}
-	
-	[Test]
-	public void ConversionToColorRGBA256DoubleIsLossless()
-	{
-		ColorRGBA256Double original = MakeRandomColor();
-		ColorRGBA256Double converted = original.Convert<ColorRGBA256Double, double, ColorRGBA256Double, double>();
-		ColorRGBA256Double convertedBack = converted.Convert<ColorRGBA256Double, double, ColorRGBA256Double, double>();
-		Assert.That(convertedBack, Is.EqualTo(original));
-	}
-}
+
+	private static TChannel MakeRandomValue() => ColorRandom<TColor, TChannel>.MakeRandomValue();
+
+	private static TColor MakeRandomColor() => ColorRandom<TColor, TChannel>.MakeRandomColor();
+}
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.g.cs
new file mode 100644
index 0000000..2f68b8a
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/GenericColorTests.g.cs
@@ -0,0 +1,69 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Rgb.Formats;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<sbyte>), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<sbyte>), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<sbyte>), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<sbyte>), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<sbyte>), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<byte>), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<byte>), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<byte>), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<byte>), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<byte>), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<short>), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<short>), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<short>), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<short>), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<short>), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<ushort>), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<ushort>), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<ushort>), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<ushort>), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<ushort>), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<int>), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<int>), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<int>), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<int>), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<int>), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<uint>), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<uint>), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<uint>), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<uint>), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<uint>), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<long>), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<long>), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<long>), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<long>), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<long>), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<ulong>), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<ulong>), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<ulong>), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<ulong>), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<ulong>), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<Half>), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<Half>), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<Half>), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<Half>), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<Half>), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<float>), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<float>), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<float>), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<float>), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<float>), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<double>), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<double>), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<double>), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<double>), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<double>), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorR<decimal>), typeof(decimal) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRG<decimal>), typeof(decimal) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGB<decimal>), typeof(decimal) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorRGBA<decimal>), typeof(decimal) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ColorA<decimal>), typeof(decimal) })]
+partial class GenericColorTests<TColor, TChannel>
+{
+}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.cs b/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.cs
new file mode 100644
index 0000000..821ef63
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.cs
@@ -0,0 +1,38 @@
+using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.Rgb.Formats;
+using System.Numerics;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+/// <summary>
+/// Tests for lossless color conversions.
+/// </summary>
+/// <typeparam name="T1">The "smaller" type that can be losslessly converted into <typeparamref name="T2"/>.</typeparam>
+/// <typeparam name="T2">The "larger" type capable of storing <typeparamref name="T1"/> losslessly.</typeparam>
+internal partial class LosslessColorTests<T1, T2>
+	where T1 : unmanaged, INumberBase<T1>, IMinMaxValue<T1>
+	where T2 : unmanaged, INumberBase<T2>, IMinMaxValue<T2>
+{
+	[Test]
+	public void ConversionIsLossless_R_T1_R_T2() => LosslessConversion.Assert<ColorR<T1>, T1, ColorR<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_R_T1_RG_T2() => LosslessConversion.Assert<ColorR<T1>, T1, ColorRG<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_R_T1_RGB_T2() => LosslessConversion.Assert<ColorR<T1>, T1, ColorRGB<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_R_T1_RGBA_T2() => LosslessConversion.Assert<ColorR<T1>, T1, ColorRGBA<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_RG_T1_RGB_T2() => LosslessConversion.Assert<ColorRG<T1>, T1, ColorRGB<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_RG_T1_RGBA_T2() => LosslessConversion.Assert<ColorRG<T1>, T1, ColorRGBA<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_RGB_T1_RGBA_T2() => LosslessConversion.Assert<ColorRGB<T1>, T1, ColorRGBA<T2>, T2>();
+
+	[Test]
+	public void ConversionIsLossless_A_T1_RGBA_T2() => LosslessConversion.Assert<ColorA<T1>, T1, ColorRGBA<T2>, T2>();
+}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.g.cs b/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.g.cs
new file mode 100644
index 0000000..13ff815
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/LosslessColorTests.g.cs
@@ -0,0 +1,55 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Rgb.Formats;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(sbyte), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(sbyte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(byte) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(byte), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(short), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(short) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(ushort) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ushort), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(int), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(int), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(int), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(int), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(uint), typeof(int) })]
+[TestFixture(TypeArgs = new Type[] { typeof(uint), typeof(uint) })]
+[TestFixture(TypeArgs = new Type[] { typeof(uint), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(uint), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(long), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(long), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ulong), typeof(long) })]
+[TestFixture(TypeArgs = new Type[] { typeof(ulong), typeof(ulong) })]
+[TestFixture(TypeArgs = new Type[] { typeof(Half), typeof(Half) })]
+[TestFixture(TypeArgs = new Type[] { typeof(Half), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(Half), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(float), typeof(float) })]
+[TestFixture(TypeArgs = new Type[] { typeof(float), typeof(double) })]
+[TestFixture(TypeArgs = new Type[] { typeof(double), typeof(double) })]
+partial class LosslessColorTests<T1, T2>
+{
+}
diff --git a/AssetRipper.TextureDecoder.Tests/Formats/LosslessConversion.cs b/AssetRipper.TextureDecoder.Tests/Formats/LosslessConversion.cs
new file mode 100644
index 0000000..fa77638
--- /dev/null
+++ b/AssetRipper.TextureDecoder.Tests/Formats/LosslessConversion.cs
@@ -0,0 +1,17 @@
+using AssetRipper.TextureDecoder.Rgb;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+internal static class LosslessConversion
+{
+	internal static void Assert<TColor1, TChannel1, TColor2, TChannel2>()
+		where TChannel1 : unmanaged
+		where TChannel2 : unmanaged
+		where TColor1 : unmanaged, IColor<TChannel1>
+		where TColor2 : unmanaged, IColor<TChannel2>
+	{
+		TColor1 original = ColorRandom<TColor1, TChannel1>.MakeRandomColor();
+		TColor2 converted = original.Convert<TColor1, TChannel1, TColor2, TChannel2>();
+		TColor1 convertedBack = converted.Convert<TColor2, TChannel2, TColor1, TChannel1>();
+		NUnit.Framework.Assert.That(convertedBack, Is.EqualTo(original));
+	}
+}
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder.Tests/NewRgbTests.cs b/AssetRipper.TextureDecoder.Tests/NewRgbTests.cs
index 3e4e49e..f823a19 100644
--- a/AssetRipper.TextureDecoder.Tests/NewRgbTests.cs
+++ b/AssetRipper.TextureDecoder.Tests/NewRgbTests.cs
@@ -13,7 +13,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
 				int bytesRead = RgbConverter.A8ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
-				RgbConverter.Convert<ColorA8, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				RgbConverter.Convert<ColorA<byte>, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
 				totalBytesRead += bytesRead;
 				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 			}
@@ -41,7 +41,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
 				int bytesRead = RgbConverter.RGB24ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
-				RgbConverter.Convert<ColorRGB24, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				RgbConverter.Convert<ColorRGB<byte>, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
 				totalBytesRead += bytesRead;
 				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 			}
@@ -56,7 +56,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
 				int bytesRead = RgbConverter.RGBA32ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
-				RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
 				totalBytesRead += bytesRead;
 				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 			}
@@ -100,7 +100,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			int totalBytesRead = 0;
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
-				int bytesRead = RgbConverter.Convert<ColorR16, ushort, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out _);
+				int bytesRead = RgbConverter.Convert<ColorR<ushort>, ushort, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out _);
 				totalBytesRead += bytesRead;
 			}
 			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
@@ -127,7 +127,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
 				int bytesRead = RgbConverter.RG16ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
-				RgbConverter.Convert<ColorRG16, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				RgbConverter.Convert<ColorRG<byte>, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
 				totalBytesRead += bytesRead;
 				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 			}
@@ -142,7 +142,7 @@ namespace AssetRipper.TextureDecoder.Tests
 			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
 			{
 				int bytesRead = RgbConverter.R8ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
-				RgbConverter.Convert<ColorR8, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				RgbConverter.Convert<ColorR<byte>, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
 				totalBytesRead += bytesRead;
 				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 			}
@@ -154,7 +154,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rhalf");
 			RgbConverter.RHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorR16Half, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorR<Half>, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -163,7 +163,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rghalf");
 			RgbConverter.RGHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRG32Half, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRG<Half>, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -171,7 +171,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		public void ConvertRGB32HalfTest()
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgb24");
-			RgbConverter.Convert<ColorRGB24, byte, ColorRGB32Half, Half>(data, 256, 256, out var halfData);
+			RgbConverter.Convert<ColorRGB<byte>, byte, ColorRGB32Half, Half>(data, 256, 256, out var halfData);
 			int legacyBytesRead = RgbConverter.R11G11B10FloatToBGRA32(halfData, 256, 256, out var legacyRgbData);
 			int bytesRead = RgbConverter.Convert<ColorRGB32Half, Half, ColorBGRA32, byte>(halfData, 256, 256, out var rgbData);
 			Assert.Multiple(() =>
@@ -187,7 +187,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgbahalf");
 			RgbConverter.RGBAHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRGBA64Half, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRGBA<Half>, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -196,7 +196,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rfloat");
 			RgbConverter.RFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorR32Single, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorR<float>, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -205,7 +205,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgfloat");
 			RgbConverter.RGFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRG64Single, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRG<float>, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -214,7 +214,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgbafloat");
 			RgbConverter.RGBAFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRGBA128Single, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRGBA<float>, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -232,7 +232,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rg32");
 			RgbConverter.RG32ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRG32, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRG<ushort>, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -241,7 +241,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgb48");
 			RgbConverter.RGB48ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRGB48, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRGB<ushort>, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 
@@ -250,7 +250,7 @@ namespace AssetRipper.TextureDecoder.Tests
 		{
 			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestFilesFolder + "test.rgba64");
 			RgbConverter.RGBA64ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
-			RgbConverter.Convert<ColorRGBA64, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			RgbConverter.Convert<ColorRGBA<ushort>, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
 			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
 		}
 	}
diff --git a/AssetRipper.TextureDecoder/Bc/Bc1.cs b/AssetRipper.TextureDecoder/Bc/Bc1.cs
index 8c410b6..12ed9d3 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc1.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc1.cs
@@ -20,12 +20,12 @@ public static class Bc1
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA32>();
+				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA<byte>>();
 				BcHelpers.DecompressBc1(input.Slice(inputOffset, BlockSize), output.Slice(outputOffset), width * 4);
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(output, width, height, output);
+		RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(output, width, height, output);
 		return inputOffset;
 	}
 
diff --git a/AssetRipper.TextureDecoder/Bc/Bc2.cs b/AssetRipper.TextureDecoder/Bc/Bc2.cs
index 9778d24..9a02998 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc2.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc2.cs
@@ -20,12 +20,12 @@ public static class Bc2
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA32>();
+				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA<byte>>();
 				BcHelpers.DecompressBc2(input.Slice(inputOffset), output.Slice(outputOffset), width * 4);
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(output, width, height, output);
+		RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(output, width, height, output);
 		return inputOffset;
 	}
 
diff --git a/AssetRipper.TextureDecoder/Bc/Bc3.cs b/AssetRipper.TextureDecoder/Bc/Bc3.cs
index 97b788a..a315ebe 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc3.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc3.cs
@@ -20,12 +20,12 @@ public static class Bc3
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA32>();
+				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA<byte>>();
 				BcHelpers.DecompressBc3(input.Slice(inputOffset), output.Slice(outputOffset), width * 4);
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(output, width, height, output);
+		RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(output, width, height, output);
 		return inputOffset;
 	}
 
diff --git a/AssetRipper.TextureDecoder/Bc/Bc4.cs b/AssetRipper.TextureDecoder/Bc/Bc4.cs
index 71d8e08..1fb39be 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc4.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc4.cs
@@ -16,7 +16,7 @@ public static class Bc4
 
 	public static int Decompress(ReadOnlySpan<byte> input, int width, int height, Span<byte> output)
 	{
-		int bufferSize = width * height * Unsafe.SizeOf<ColorR8>();
+		int bufferSize = width * height * Unsafe.SizeOf<ColorR<byte>>();
 		byte[] bufferArray = ArrayPool<byte>.Shared.Rent(bufferSize);
 		Span<byte> buffer = new Span<byte>(bufferArray, 0, bufferSize);
 		int inputOffset = 0;
@@ -24,12 +24,12 @@ public static class Bc4
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int bufferOffset = ((i * width) + j) * Unsafe.SizeOf<ColorR8>();
+				int bufferOffset = ((i * width) + j) * Unsafe.SizeOf<ColorR<byte>>();
 				BcHelpers.DecompressBc4(input.Slice(inputOffset), buffer.Slice(bufferOffset), width);
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorR8, byte, ColorBGRA32, byte>(buffer, width, height, output);
+		RgbConverter.Convert<ColorR<byte>, byte, ColorBGRA32, byte>(buffer, width, height, output);
 		ArrayPool<byte>.Shared.Return(bufferArray);
 		return inputOffset;
 	}
diff --git a/AssetRipper.TextureDecoder/Bc/Bc5.cs b/AssetRipper.TextureDecoder/Bc/Bc5.cs
index a8dff46..d08213f 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc5.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc5.cs
@@ -16,7 +16,7 @@ public static class Bc5
 
 	public static int Decompress(ReadOnlySpan<byte> input, int width, int height, Span<byte> output)
 	{
-		int bufferSize = width * height * Unsafe.SizeOf<ColorRG16>();
+		int bufferSize = width * height * Unsafe.SizeOf<ColorRG<byte>>();
 		byte[] bufferArray = ArrayPool<byte>.Shared.Rent(bufferSize);
 		Span<byte> buffer = new Span<byte>(bufferArray, 0, bufferSize);
 		int inputOffset = 0;
@@ -24,12 +24,12 @@ public static class Bc5
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int bufferOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRG16>();
+				int bufferOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRG<byte>>();
 				BcHelpers.DecompressBc5(input.Slice(inputOffset), buffer.Slice(bufferOffset), width * 2);
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRG16, byte, ColorBGRA32, byte>(buffer, width, height, output);
+		RgbConverter.Convert<ColorRG<byte>, byte, ColorBGRA32, byte>(buffer, width, height, output);
 		ArrayPool<byte>.Shared.Return(bufferArray);
 		return inputOffset;
 	}
diff --git a/AssetRipper.TextureDecoder/Bc/Bc6h.cs b/AssetRipper.TextureDecoder/Bc/Bc6h.cs
index 47cf815..117cd55 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc6h.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc6h.cs
@@ -16,7 +16,7 @@ public static class Bc6h
 
 	public static int Decompress(ReadOnlySpan<byte> input, int width, int height, bool isSigned, Span<byte> output)
 	{
-		int bufferSize = width * height * Unsafe.SizeOf<ColorRGB48Half>();
+		int bufferSize = width * height * Unsafe.SizeOf<ColorRGB<Half>>();
 		byte[] bufferArray = ArrayPool<byte>.Shared.Rent(bufferSize);
 		Span<byte> buffer = new Span<byte>(bufferArray, 0, bufferSize);
 		int inputOffset = 0;
@@ -24,7 +24,7 @@ public static class Bc6h
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGB48Half>();
+				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGB<Half>>();
 				BcHelpers.DecompressBc6h(
 					input.Slice(inputOffset, BlockSize),
 					buffer.Slice(outputOffset),
@@ -33,7 +33,7 @@ public static class Bc6h
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRGB48Half, Half, ColorBGRA32, byte>(buffer, width, height, output);
+		RgbConverter.Convert<ColorRGB<Half>, Half, ColorBGRA32, byte>(buffer, width, height, output);
 		ArrayPool<byte>.Shared.Return(bufferArray);
 		return inputOffset;
 	}
diff --git a/AssetRipper.TextureDecoder/Bc/Bc7.cs b/AssetRipper.TextureDecoder/Bc/Bc7.cs
index 5f1dfed..781f0e3 100644
--- a/AssetRipper.TextureDecoder/Bc/Bc7.cs
+++ b/AssetRipper.TextureDecoder/Bc/Bc7.cs
@@ -20,7 +20,7 @@ public static class Bc7
 		{
 			for (int j = 0; j < width; j += 4)
 			{
-				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA32>();
+				int outputOffset = ((i * width) + j) * Unsafe.SizeOf<ColorRGBA<byte>>();
 				BcHelpers.DecompressBc7(
 					input.Slice(inputOffset, BlockSize), 
 					output.Slice(outputOffset),
@@ -28,7 +28,7 @@ public static class Bc7
 				inputOffset += BlockSize;
 			}
 		}
-		RgbConverter.Convert<ColorRGBA32, byte, ColorBGRA32, byte>(output, width, height, output);
+		RgbConverter.Convert<ColorRGBA<byte>, byte, ColorBGRA32, byte>(output, width, height, output);
 		return inputOffset;
 	}
 
diff --git a/AssetRipper.TextureDecoder/GlobalUsings.cs b/AssetRipper.TextureDecoder/GlobalUsings.cs
index 94f79b5..a938a10 100644
--- a/AssetRipper.TextureDecoder/GlobalUsings.cs
+++ b/AssetRipper.TextureDecoder/GlobalUsings.cs
@@ -1,2 +1,3 @@
 global using System;
+global using System.Numerics;
 global using System.Runtime.CompilerServices;
\ No newline at end of file
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorA.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorA.g.cs
new file mode 100644
index 0000000..1bc4710
--- /dev/null
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorA.g.cs
@@ -0,0 +1,52 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Attributes;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats;
+
+[RgbaAttribute(RedChannel = false, GreenChannel = false, BlueChannel = false, AlphaChannel = true, FullyUtilizedChannels = true)]
+public partial struct ColorA<T> : IColor<T> where T : unmanaged, INumberBase<T>, IMinMaxValue<T>
+{
+	public readonly T R 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public readonly T G 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public readonly T B 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public T A { get; set; }
+
+	public readonly void GetChannels(out T r, out T g, out T b, out T a)
+	{
+		r = R;
+		g = G;
+		b = B;
+		a = A;
+	}
+
+	public void SetChannels(T r, T g, T b, T a)
+	{
+		A = a;
+	}
+
+	static bool IColor<T>.HasRedChannel => false;
+	static bool IColor<T>.HasGreenChannel => false;
+	static bool IColor<T>.HasBlueChannel => false;
+	static bool IColor<T>.HasAlphaChannel => true;
+
+	public override string ToString()
+	{
+		return $"{{ A: {A} }}";
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorA8.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorA8.g.cs
deleted file mode 100644
index 96bd281..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorA8.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = false, GreenChannel = false, BlueChannel = false, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorA8 : IColor<byte>
-	{
-		public readonly byte R 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public readonly byte G 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public readonly byte B 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public byte A { get; set; }
-		
-		public readonly void GetChannels(out byte r, out byte g, out byte b, out byte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(byte r, byte g, byte b, byte a)
-		{
-			A = a;
-		}
-		
-		static bool IColor<byte>.HasRedChannel => false;
-		static bool IColor<byte>.HasGreenChannel => false;
-		static bool IColor<byte>.HasBlueChannel => false;
-		static bool IColor<byte>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB16.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB16.g.cs
index 826fa34..0951741 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB16.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB16.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<byte>.HasGreenChannel => true;
 		static bool IColor<byte>.HasBlueChannel => true;
 		static bool IColor<byte>.HasAlphaChannel => true;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B}, A: {A} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB32.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB32.g.cs
index 7fcd18a..7c2e6c7 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB32.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorARGB32.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<byte>.HasGreenChannel => true;
 		static bool IColor<byte>.HasBlueChannel => true;
 		static bool IColor<byte>.HasAlphaChannel => true;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B}, A: {A} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorBGRA32.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorBGRA32.g.cs
index 9e0e153..1cae8f4 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorBGRA32.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorBGRA32.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<byte>.HasGreenChannel => true;
 		static bool IColor<byte>.HasBlueChannel => true;
 		static bool IColor<byte>.HasAlphaChannel => true;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B}, A: {A} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR.g.cs
new file mode 100644
index 0000000..5e83550
--- /dev/null
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR.g.cs
@@ -0,0 +1,52 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Attributes;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats;
+
+[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
+public partial struct ColorR<T> : IColor<T> where T : unmanaged, INumberBase<T>, IMinMaxValue<T>
+{
+	public T R { get; set; }
+
+	public readonly T G 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public readonly T B 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public readonly T A 
+	{
+		get => NumericConversion.GetMaximumValue<T>();
+		set { }
+	}
+
+	public readonly void GetChannels(out T r, out T g, out T b, out T a)
+	{
+		r = R;
+		g = G;
+		b = B;
+		a = A;
+	}
+
+	public void SetChannels(T r, T g, T b, T a)
+	{
+		R = r;
+	}
+
+	static bool IColor<T>.HasRedChannel => true;
+	static bool IColor<T>.HasGreenChannel => false;
+	static bool IColor<T>.HasBlueChannel => false;
+	static bool IColor<T>.HasAlphaChannel => false;
+
+	public override string ToString()
+	{
+		return $"{{ R: {R} }}";
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16.g.cs
deleted file mode 100644
index e10affd..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR16 : IColor<ushort>
-	{
-		public ushort R { get; set; }
-		
-		public readonly ushort G 
-		{
-			get => ushort.MinValue;
-			set { }
-		}
-		
-		public readonly ushort B 
-		{
-			get => ushort.MinValue;
-			set { }
-		}
-		
-		public readonly ushort A 
-		{
-			get => ushort.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<ushort>.HasRedChannel => true;
-		static bool IColor<ushort>.HasGreenChannel => false;
-		static bool IColor<ushort>.HasBlueChannel => false;
-		static bool IColor<ushort>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Half.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Half.g.cs
deleted file mode 100644
index 5d85484..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Half.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR16Half : IColor<Half>
-	{
-		public Half R { get; set; }
-		
-		public readonly Half G 
-		{
-			get => default;
-			set { }
-		}
-		
-		public readonly Half B 
-		{
-			get => default;
-			set { }
-		}
-		
-		public readonly Half A 
-		{
-			get => Half.One;
-			set { }
-		}
-		
-		public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(Half r, Half g, Half b, Half a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<Half>.HasRedChannel => true;
-		static bool IColor<Half>.HasGreenChannel => false;
-		static bool IColor<Half>.HasBlueChannel => false;
-		static bool IColor<Half>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Signed.g.cs
deleted file mode 100644
index ad06e97..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Signed.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR16Signed : IColor<short>
-	{
-		public short R { get; set; }
-		
-		public readonly short G 
-		{
-			get => short.MinValue;
-			set { }
-		}
-		
-		public readonly short B 
-		{
-			get => short.MinValue;
-			set { }
-		}
-		
-		public readonly short A 
-		{
-			get => short.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out short r, out short g, out short b, out short a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(short r, short g, short b, short a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<short>.HasRedChannel => true;
-		static bool IColor<short>.HasGreenChannel => false;
-		static bool IColor<short>.HasBlueChannel => false;
-		static bool IColor<short>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR32Single.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR32Single.g.cs
deleted file mode 100644
index 50e7fea..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR32Single.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR32Single : IColor<float>
-	{
-		public float R { get; set; }
-		
-		public readonly float G 
-		{
-			get => 0f;
-			set { }
-		}
-		
-		public readonly float B 
-		{
-			get => 0f;
-			set { }
-		}
-		
-		public readonly float A 
-		{
-			get => 1f;
-			set { }
-		}
-		
-		public readonly void GetChannels(out float r, out float g, out float b, out float a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(float r, float g, float b, float a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<float>.HasRedChannel => true;
-		static bool IColor<float>.HasGreenChannel => false;
-		static bool IColor<float>.HasBlueChannel => false;
-		static bool IColor<float>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR64Double.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR64Double.g.cs
deleted file mode 100644
index 8f795c6..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR64Double.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR64Double : IColor<double>
-	{
-		public double R { get; set; }
-		
-		public readonly double G 
-		{
-			get => 0d;
-			set { }
-		}
-		
-		public readonly double B 
-		{
-			get => 0d;
-			set { }
-		}
-		
-		public readonly double A 
-		{
-			get => 1d;
-			set { }
-		}
-		
-		public readonly void GetChannels(out double r, out double g, out double b, out double a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(double r, double g, double b, double a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<double>.HasRedChannel => true;
-		static bool IColor<double>.HasGreenChannel => false;
-		static bool IColor<double>.HasBlueChannel => false;
-		static bool IColor<double>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8.g.cs
deleted file mode 100644
index 0b889c7..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR8 : IColor<byte>
-	{
-		public byte R { get; set; }
-		
-		public readonly byte G 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public readonly byte B 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public readonly byte A 
-		{
-			get => byte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out byte r, out byte g, out byte b, out byte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(byte r, byte g, byte b, byte a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<byte>.HasRedChannel => true;
-		static bool IColor<byte>.HasGreenChannel => false;
-		static bool IColor<byte>.HasBlueChannel => false;
-		static bool IColor<byte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8Signed.g.cs
deleted file mode 100644
index 9fddb68..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorR8Signed.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = false, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorR8Signed : IColor<sbyte>
-	{
-		public sbyte R { get; set; }
-		
-		public readonly sbyte G 
-		{
-			get => sbyte.MinValue;
-			set { }
-		}
-		
-		public readonly sbyte B 
-		{
-			get => sbyte.MinValue;
-			set { }
-		}
-		
-		public readonly sbyte A 
-		{
-			get => sbyte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
-		{
-			R = r;
-		}
-		
-		static bool IColor<sbyte>.HasRedChannel => true;
-		static bool IColor<sbyte>.HasGreenChannel => false;
-		static bool IColor<sbyte>.HasBlueChannel => false;
-		static bool IColor<sbyte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG.g.cs
new file mode 100644
index 0000000..1170aef
--- /dev/null
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG.g.cs
@@ -0,0 +1,49 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Attributes;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats;
+
+[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
+public partial struct ColorRG<T> : IColor<T> where T : unmanaged, INumberBase<T>, IMinMaxValue<T>
+{
+	public T R { get; set; }
+
+	public T G { get; set; }
+
+	public readonly T B 
+	{
+		get => NumericConversion.GetMinimumValue<T>();
+		set { }
+	}
+
+	public readonly T A 
+	{
+		get => NumericConversion.GetMaximumValue<T>();
+		set { }
+	}
+
+	public readonly void GetChannels(out T r, out T g, out T b, out T a)
+	{
+		r = R;
+		g = G;
+		b = B;
+		a = A;
+	}
+
+	public void SetChannels(T r, T g, T b, T a)
+	{
+		R = r;
+		G = g;
+	}
+
+	static bool IColor<T>.HasRedChannel => true;
+	static bool IColor<T>.HasGreenChannel => true;
+	static bool IColor<T>.HasBlueChannel => false;
+	static bool IColor<T>.HasAlphaChannel => false;
+
+	public override string ToString()
+	{
+		return $"{{ R: {R}, G: {G} }}";
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG128Double.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG128Double.g.cs
deleted file mode 100644
index 4ba3157..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG128Double.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG128Double : IColor<double>
-	{
-		public double R { get; set; }
-		
-		public double G { get; set; }
-		
-		public readonly double B 
-		{
-			get => 0d;
-			set { }
-		}
-		
-		public readonly double A 
-		{
-			get => 1d;
-			set { }
-		}
-		
-		public readonly void GetChannels(out double r, out double g, out double b, out double a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(double r, double g, double b, double a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<double>.HasRedChannel => true;
-		static bool IColor<double>.HasGreenChannel => true;
-		static bool IColor<double>.HasBlueChannel => false;
-		static bool IColor<double>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16.g.cs
deleted file mode 100644
index 07492f9..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG16 : IColor<byte>
-	{
-		public byte R { get; set; }
-		
-		public byte G { get; set; }
-		
-		public readonly byte B 
-		{
-			get => byte.MinValue;
-			set { }
-		}
-		
-		public readonly byte A 
-		{
-			get => byte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out byte r, out byte g, out byte b, out byte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(byte r, byte g, byte b, byte a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<byte>.HasRedChannel => true;
-		static bool IColor<byte>.HasGreenChannel => true;
-		static bool IColor<byte>.HasBlueChannel => false;
-		static bool IColor<byte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16Signed.g.cs
deleted file mode 100644
index e79a70e..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16Signed.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG16Signed : IColor<sbyte>
-	{
-		public sbyte R { get; set; }
-		
-		public sbyte G { get; set; }
-		
-		public readonly sbyte B 
-		{
-			get => sbyte.MinValue;
-			set { }
-		}
-		
-		public readonly sbyte A 
-		{
-			get => sbyte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<sbyte>.HasRedChannel => true;
-		static bool IColor<sbyte>.HasGreenChannel => true;
-		static bool IColor<sbyte>.HasBlueChannel => false;
-		static bool IColor<sbyte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32.g.cs
deleted file mode 100644
index ee8842c..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG32 : IColor<ushort>
-	{
-		public ushort R { get; set; }
-		
-		public ushort G { get; set; }
-		
-		public readonly ushort B 
-		{
-			get => ushort.MinValue;
-			set { }
-		}
-		
-		public readonly ushort A 
-		{
-			get => ushort.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<ushort>.HasRedChannel => true;
-		static bool IColor<ushort>.HasGreenChannel => true;
-		static bool IColor<ushort>.HasBlueChannel => false;
-		static bool IColor<ushort>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Half.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Half.g.cs
deleted file mode 100644
index fe46598..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Half.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG32Half : IColor<Half>
-	{
-		public Half R { get; set; }
-		
-		public Half G { get; set; }
-		
-		public readonly Half B 
-		{
-			get => default;
-			set { }
-		}
-		
-		public readonly Half A 
-		{
-			get => Half.One;
-			set { }
-		}
-		
-		public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(Half r, Half g, Half b, Half a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<Half>.HasRedChannel => true;
-		static bool IColor<Half>.HasGreenChannel => true;
-		static bool IColor<Half>.HasBlueChannel => false;
-		static bool IColor<Half>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Signed.g.cs
deleted file mode 100644
index 50566af..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Signed.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG32Signed : IColor<short>
-	{
-		public short R { get; set; }
-		
-		public short G { get; set; }
-		
-		public readonly short B 
-		{
-			get => short.MinValue;
-			set { }
-		}
-		
-		public readonly short A 
-		{
-			get => short.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out short r, out short g, out short b, out short a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(short r, short g, short b, short a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<short>.HasRedChannel => true;
-		static bool IColor<short>.HasGreenChannel => true;
-		static bool IColor<short>.HasBlueChannel => false;
-		static bool IColor<short>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG64Single.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG64Single.g.cs
deleted file mode 100644
index 2b5af90..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRG64Single.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = false, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRG64Single : IColor<float>
-	{
-		public float R { get; set; }
-		
-		public float G { get; set; }
-		
-		public readonly float B 
-		{
-			get => 0f;
-			set { }
-		}
-		
-		public readonly float A 
-		{
-			get => 1f;
-			set { }
-		}
-		
-		public readonly void GetChannels(out float r, out float g, out float b, out float a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(float r, float g, float b, float a)
-		{
-			R = r;
-			G = g;
-		}
-		
-		static bool IColor<float>.HasRedChannel => true;
-		static bool IColor<float>.HasGreenChannel => true;
-		static bool IColor<float>.HasBlueChannel => false;
-		static bool IColor<float>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB.g.cs
new file mode 100644
index 0000000..2d8e1da
--- /dev/null
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB.g.cs
@@ -0,0 +1,46 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Attributes;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats;
+
+[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
+public partial struct ColorRGB<T> : IColor<T> where T : unmanaged, INumberBase<T>, IMinMaxValue<T>
+{
+	public T R { get; set; }
+
+	public T G { get; set; }
+
+	public T B { get; set; }
+
+	public readonly T A 
+	{
+		get => NumericConversion.GetMaximumValue<T>();
+		set { }
+	}
+
+	public readonly void GetChannels(out T r, out T g, out T b, out T a)
+	{
+		r = R;
+		g = G;
+		b = B;
+		a = A;
+	}
+
+	public void SetChannels(T r, T g, T b, T a)
+	{
+		R = r;
+		G = g;
+		B = b;
+	}
+
+	static bool IColor<T>.HasRedChannel => true;
+	static bool IColor<T>.HasGreenChannel => true;
+	static bool IColor<T>.HasBlueChannel => true;
+	static bool IColor<T>.HasAlphaChannel => false;
+
+	public override string ToString()
+	{
+		return $"{{ R: {R}, G: {G}, B: {B} }}";
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB16.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB16.g.cs
index f777392..ac97a56 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB16.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB16.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<byte>.HasGreenChannel => true;
 		static bool IColor<byte>.HasBlueChannel => true;
 		static bool IColor<byte>.HasAlphaChannel => false;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB192Double.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB192Double.g.cs
deleted file mode 100644
index 94ce839..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB192Double.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB192Double : IColor<double>
-	{
-		public double R { get; set; }
-		
-		public double G { get; set; }
-		
-		public double B { get; set; }
-		
-		public readonly double A 
-		{
-			get => 1d;
-			set { }
-		}
-		
-		public readonly void GetChannels(out double r, out double g, out double b, out double a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(double r, double g, double b, double a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<double>.HasRedChannel => true;
-		static bool IColor<double>.HasGreenChannel => true;
-		static bool IColor<double>.HasBlueChannel => true;
-		static bool IColor<double>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24.g.cs
deleted file mode 100644
index 0d9825d..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB24 : IColor<byte>
-	{
-		public byte R { get; set; }
-		
-		public byte G { get; set; }
-		
-		public byte B { get; set; }
-		
-		public readonly byte A 
-		{
-			get => byte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out byte r, out byte g, out byte b, out byte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(byte r, byte g, byte b, byte a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<byte>.HasRedChannel => true;
-		static bool IColor<byte>.HasGreenChannel => true;
-		static bool IColor<byte>.HasBlueChannel => true;
-		static bool IColor<byte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24Signed.g.cs
deleted file mode 100644
index b0bfde2..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24Signed.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB24Signed : IColor<sbyte>
-	{
-		public sbyte R { get; set; }
-		
-		public sbyte G { get; set; }
-		
-		public sbyte B { get; set; }
-		
-		public readonly sbyte A 
-		{
-			get => sbyte.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<sbyte>.HasRedChannel => true;
-		static bool IColor<sbyte>.HasGreenChannel => true;
-		static bool IColor<sbyte>.HasBlueChannel => true;
-		static bool IColor<sbyte>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.cs
index b5f3ff2..bbb4b34 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.cs
@@ -1,64 +1,74 @@
 namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-    /// <summary>
-    /// Also called R11G11B10_FLOAT
-    /// </summary>
-    /// <remarks>
-    /// <see href="https://github.com/microsoft/DirectX-Graphics-Samples/blob/e5ea2ac7430ce39e6f6d619fd85ae32581931589/MiniEngine/Core/Shaders/PixelPacking_R11G11B10.hlsli#L31-L37" />
-    /// </remarks>
-    public partial struct ColorRGB32Half : IColor<Half>
-    {
-        private uint bits;
-
-        /// <summary>
-        /// 11 bits
-        /// </summary>
-        public Half R {
-			readonly get {
-                var value = (ushort) ((bits << 4) & 0x7FF0);
-                return Unsafe.As<ushort, Half>(ref value);
-            }
-            set => bits = (uint) ((bits & ~0x7FF) | ((uint) Unsafe.As<Half, ushort>(ref value) & 0x7FF0) >> 4);
-        }
-
-        /// <summary>
-        /// 11 bits
-        /// </summary>
-        public Half G {
-			readonly get {
-                var value = (ushort) ((bits >> 7) & 0x7FF0);
-                return Unsafe.As<ushort, Half>(ref value);
-            }
-            set => bits = (uint) ((bits & ~0x3FF800) | (((uint) Unsafe.As<Half, ushort>(ref value) >> 4) & 0x7FF0) << 11);
-        }
-
-        /// <summary>
-        /// 10 bits
-        /// </summary>
-        public Half B {
-			readonly get {
-                var value = (ushort) ((bits >> 17) & 0x7FE0);
-                return Unsafe.As<ushort, Half>(ref value);
-            }
-            set => bits = (bits & ~0xFFC00000) | ((((uint) Unsafe.As<Half, ushort>(ref value) >> 5) & 0x3FF) << 22);
-        }
-
-        public readonly Half A
-        {
-            get => (Half) 1.0f;
-			set { }
-        }
-
-        public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
-        {
-            DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
-        }
-
-        public void SetChannels(Half r, Half g, Half b, Half a)
-        {
-            bits = (((uint) Unsafe.As<Half, ushort>(ref r) >> 4) & 0x7FF) |
-                   ((((uint) Unsafe.As<Half, ushort>(ref g) >> 4) & 0x7FF) << 11) |
-                   ((((uint) Unsafe.As<Half, ushort>(ref b) >> 5) & 0x3FF) << 22);
-        }
-    }
+{
+	/// <summary>
+	/// Also called R11G11B10_FLOAT
+	/// </summary>
+	/// <remarks>
+	/// <see href="https://github.com/microsoft/DirectX-Graphics-Samples/blob/e5ea2ac7430ce39e6f6d619fd85ae32581931589/MiniEngine/Core/Shaders/PixelPacking_R11G11B10.hlsli#L31-L37" />
+	/// </remarks>
+	public partial struct ColorRGB32Half : IColor<Half>
+	{
+		private uint bits;
+
+		/// <summary>
+		/// 11 bits
+		/// </summary>
+		public Half R
+		{
+			readonly get
+			{
+				ushort value = (ushort)((bits << 4) & 0x7FF0u);
+				return ToHalf(value);
+			}
+			set => bits = (bits & ~0x7FFu) | (ToUInt32(value) & 0x7FF0u) >> 4;
+		}
+
+		/// <summary>
+		/// 11 bits
+		/// </summary>
+		public Half G
+		{
+			readonly get
+			{
+				ushort value = (ushort)((bits >> 7) & 0x7FF0);
+				return ToHalf(value);
+			}
+			set => bits = (bits & ~0x3FF800u) | ((ToUInt32(value) >> 4) & 0x7FF0u) << 11;
+		}
+
+		/// <summary>
+		/// 10 bits
+		/// </summary>
+		public Half B
+		{
+			readonly get
+			{
+				ushort value = (ushort)((bits >> 17) & 0x7FE0);
+				return ToHalf(value);
+			}
+			set => bits = (bits & ~0xFFC00000u) | (((ToUInt32(value) >> 5) & 0x3FFu) << 22);
+		}
+
+		public readonly Half A
+		{
+			get => Half.One;
+			set { }
+		}
+
+		public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+
+		public void SetChannels(Half r, Half g, Half b, Half a)
+		{
+			bits = ((ToUInt32(r) >> 4) & 0x7FF) | (((ToUInt32(g) >> 4) & 0x7FF) << 11) | (((ToUInt32(b) >> 5) & 0x3FF) << 22);
+		}
+
+		private static Half ToHalf(ushort value) => Unsafe.As<ushort, Half>(ref Unsafe.AsRef(value));
+
+		private static ushort ToUInt16(Half value) => Unsafe.As<Half, ushort>(ref Unsafe.AsRef(value));
+
+		private static uint ToUInt32(Half value) => ToUInt16(value);
+	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.g.cs
index acd2828..fed3357 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB32Half.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<Half>.HasGreenChannel => true;
 		static bool IColor<Half>.HasBlueChannel => true;
 		static bool IColor<Half>.HasAlphaChannel => false;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48.g.cs
deleted file mode 100644
index 7ac5136..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB48 : IColor<ushort>
-	{
-		public ushort R { get; set; }
-		
-		public ushort G { get; set; }
-		
-		public ushort B { get; set; }
-		
-		public readonly ushort A 
-		{
-			get => ushort.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<ushort>.HasRedChannel => true;
-		static bool IColor<ushort>.HasGreenChannel => true;
-		static bool IColor<ushort>.HasBlueChannel => true;
-		static bool IColor<ushort>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Half.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Half.g.cs
deleted file mode 100644
index 4476de3..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Half.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB48Half : IColor<Half>
-	{
-		public Half R { get; set; }
-		
-		public Half G { get; set; }
-		
-		public Half B { get; set; }
-		
-		public readonly Half A 
-		{
-			get => Half.One;
-			set { }
-		}
-		
-		public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(Half r, Half g, Half b, Half a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<Half>.HasRedChannel => true;
-		static bool IColor<Half>.HasGreenChannel => true;
-		static bool IColor<Half>.HasBlueChannel => true;
-		static bool IColor<Half>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Signed.g.cs
deleted file mode 100644
index 64fd7ae..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Signed.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB48Signed : IColor<short>
-	{
-		public short R { get; set; }
-		
-		public short G { get; set; }
-		
-		public short B { get; set; }
-		
-		public readonly short A 
-		{
-			get => short.MaxValue;
-			set { }
-		}
-		
-		public readonly void GetChannels(out short r, out short g, out short b, out short a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(short r, short g, short b, short a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<short>.HasRedChannel => true;
-		static bool IColor<short>.HasGreenChannel => true;
-		static bool IColor<short>.HasBlueChannel => true;
-		static bool IColor<short>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB96Single.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB96Single.g.cs
deleted file mode 100644
index 2d8fd8b..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB96Single.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = false, FullyUtilizedChannels = true)]
-	public partial struct ColorRGB96Single : IColor<float>
-	{
-		public float R { get; set; }
-		
-		public float G { get; set; }
-		
-		public float B { get; set; }
-		
-		public readonly float A 
-		{
-			get => 1f;
-			set { }
-		}
-		
-		public readonly void GetChannels(out float r, out float g, out float b, out float a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(float r, float g, float b, float a)
-		{
-			R = r;
-			G = g;
-			B = b;
-		}
-		
-		static bool IColor<float>.HasRedChannel => true;
-		static bool IColor<float>.HasGreenChannel => true;
-		static bool IColor<float>.HasBlueChannel => true;
-		static bool IColor<float>.HasAlphaChannel => false;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB9e5.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB9e5.g.cs
index 40637a3..f8466c0 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB9e5.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB9e5.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<double>.HasGreenChannel => true;
 		static bool IColor<double>.HasBlueChannel => true;
 		static bool IColor<double>.HasAlphaChannel => false;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA.g.cs
new file mode 100644
index 0000000..b515d45
--- /dev/null
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA.g.cs
@@ -0,0 +1,43 @@
+// Auto-generated code. Do not modify manually.
+
+using AssetRipper.TextureDecoder.Attributes;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats;
+
+[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
+public partial struct ColorRGBA<T> : IColor<T> where T : unmanaged
+{
+	public T R { get; set; }
+
+	public T G { get; set; }
+
+	public T B { get; set; }
+
+	public T A { get; set; }
+
+	public readonly void GetChannels(out T r, out T g, out T b, out T a)
+	{
+		r = R;
+		g = G;
+		b = B;
+		a = A;
+	}
+
+	public void SetChannels(T r, T g, T b, T a)
+	{
+		R = r;
+		G = g;
+		B = b;
+		A = a;
+	}
+
+	static bool IColor<T>.HasRedChannel => true;
+	static bool IColor<T>.HasGreenChannel => true;
+	static bool IColor<T>.HasBlueChannel => true;
+	static bool IColor<T>.HasAlphaChannel => true;
+
+	public override string ToString()
+	{
+		return $"{{ R: {R}, G: {G}, B: {B}, A: {A} }}";
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA128Single.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA128Single.g.cs
deleted file mode 100644
index 32125a5..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA128Single.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA128Single : IColor<float>
-	{
-		public float R { get; set; }
-		
-		public float G { get; set; }
-		
-		public float B { get; set; }
-		
-		public float A { get; set; }
-		
-		public readonly void GetChannels(out float r, out float g, out float b, out float a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(float r, float g, float b, float a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<float>.HasRedChannel => true;
-		static bool IColor<float>.HasGreenChannel => true;
-		static bool IColor<float>.HasBlueChannel => true;
-		static bool IColor<float>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA16.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA16.g.cs
index 9341459..b09b32d 100644
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA16.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA16.g.cs
@@ -11,5 +11,10 @@ namespace AssetRipper.TextureDecoder.Rgb.Formats
 		static bool IColor<byte>.HasGreenChannel => true;
 		static bool IColor<byte>.HasBlueChannel => true;
 		static bool IColor<byte>.HasAlphaChannel => true;
+
+		public override string ToString()
+		{
+			return $"{{ R: {R}, G: {G}, B: {B}, A: {A} }}";
+		}
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA256Double.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA256Double.g.cs
deleted file mode 100644
index d1795e0..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA256Double.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA256Double : IColor<double>
-	{
-		public double R { get; set; }
-		
-		public double G { get; set; }
-		
-		public double B { get; set; }
-		
-		public double A { get; set; }
-		
-		public readonly void GetChannels(out double r, out double g, out double b, out double a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(double r, double g, double b, double a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<double>.HasRedChannel => true;
-		static bool IColor<double>.HasGreenChannel => true;
-		static bool IColor<double>.HasBlueChannel => true;
-		static bool IColor<double>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32.g.cs
deleted file mode 100644
index bf55144..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA32 : IColor<byte>
-	{
-		public byte R { get; set; }
-		
-		public byte G { get; set; }
-		
-		public byte B { get; set; }
-		
-		public byte A { get; set; }
-		
-		public readonly void GetChannels(out byte r, out byte g, out byte b, out byte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(byte r, byte g, byte b, byte a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<byte>.HasRedChannel => true;
-		static bool IColor<byte>.HasGreenChannel => true;
-		static bool IColor<byte>.HasBlueChannel => true;
-		static bool IColor<byte>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32Signed.g.cs
deleted file mode 100644
index b273d43..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32Signed.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA32Signed : IColor<sbyte>
-	{
-		public sbyte R { get; set; }
-		
-		public sbyte G { get; set; }
-		
-		public sbyte B { get; set; }
-		
-		public sbyte A { get; set; }
-		
-		public readonly void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<sbyte>.HasRedChannel => true;
-		static bool IColor<sbyte>.HasGreenChannel => true;
-		static bool IColor<sbyte>.HasBlueChannel => true;
-		static bool IColor<sbyte>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64.g.cs
deleted file mode 100644
index 776e6a3..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA64 : IColor<ushort>
-	{
-		public ushort R { get; set; }
-		
-		public ushort G { get; set; }
-		
-		public ushort B { get; set; }
-		
-		public ushort A { get; set; }
-		
-		public readonly void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<ushort>.HasRedChannel => true;
-		static bool IColor<ushort>.HasGreenChannel => true;
-		static bool IColor<ushort>.HasBlueChannel => true;
-		static bool IColor<ushort>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Half.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Half.g.cs
deleted file mode 100644
index 1376775..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Half.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA64Half : IColor<Half>
-	{
-		public Half R { get; set; }
-		
-		public Half G { get; set; }
-		
-		public Half B { get; set; }
-		
-		public Half A { get; set; }
-		
-		public readonly void GetChannels(out Half r, out Half g, out Half b, out Half a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(Half r, Half g, Half b, Half a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<Half>.HasRedChannel => true;
-		static bool IColor<Half>.HasGreenChannel => true;
-		static bool IColor<Half>.HasBlueChannel => true;
-		static bool IColor<Half>.HasAlphaChannel => true;
-	}
-}
diff --git a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Signed.g.cs b/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Signed.g.cs
deleted file mode 100644
index d747d71..0000000
--- a/AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Signed.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//This code is source generated. Do not edit manually.
-
-using AssetRipper.TextureDecoder.Attributes;
-
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-	[RgbaAttribute(RedChannel = true, GreenChannel = true, BlueChannel = true, AlphaChannel = true, FullyUtilizedChannels = true)]
-	public partial struct ColorRGBA64Signed : IColor<short>
-	{
-		public short R { get; set; }
-		
-		public short G { get; set; }
-		
-		public short B { get; set; }
-		
-		public short A { get; set; }
-		
-		public readonly void GetChannels(out short r, out short g, out short b, out short a)
-		{
-			r = R;
-			g = G;
-			b = B;
-			a = A;
-		}
-		
-		public void SetChannels(short r, short g, short b, short a)
-		{
-			R = r;
-			G = g;
-			B = b;
-			A = a;
-		}
-		
-		static bool IColor<short>.HasRedChannel => true;
-		static bool IColor<short>.HasGreenChannel => true;
-		static bool IColor<short>.HasBlueChannel => true;
-		static bool IColor<short>.HasAlphaChannel => true;
-	}
-}
diff --git a/TextureDecoder.sln b/TextureDecoder.sln
index 61f9319..e1f174c 100644
--- a/TextureDecoder.sln
+++ b/TextureDecoder.sln
@@ -35,6 +35,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssetRipper.TextureDecoder.
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegerConversion.ConstantEstimation", "IntegerConversion.ConstantEstimation\IntegerConversion.ConstantEstimation.csproj", "{9897C52D-2F38-405A-AB85-B06383FDF6E0}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssetRipper.TextureDecoder.SourceGeneration.Common", "AssetRipper.TextureDecoder.SourceGeneration.Common\AssetRipper.TextureDecoder.SourceGeneration.Common.csproj", "{336CF443-373C-41B3-8E7C-881672E9875E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -69,6 +71,10 @@ Global
 		{9897C52D-2F38-405A-AB85-B06383FDF6E0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9897C52D-2F38-405A-AB85-B06383FDF6E0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9897C52D-2F38-405A-AB85-B06383FDF6E0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{336CF443-373C-41B3-8E7C-881672E9875E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{336CF443-373C-41B3-8E7C-881672E9875E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{336CF443-373C-41B3-8E7C-881672E9875E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{336CF443-373C-41B3-8E7C-881672E9875E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE