Signed RGB color support with new source generation for standard RGB formats

AssetRipper.TextureDecoder.ColorGenerator/AssetRipper.TextureDecoder.ColorGenerator.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>net6.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+</Project>

AssetRipper.TextureDecoder.ColorGenerator/Program.cs

@@ -0,0 +1,167 @@
+using System.CodeDom.Compiler;
+
+namespace AssetRipper.TextureDecoder.ColorGenerator;
+
+internal class Program
+{
+	private const string OutputNamespace = "AssetRipper.TextureDecoder.Rgb.Formats";
+	private const string OutputFolder = "../../../../AssetRipper.TextureDecoder/Rgb/Formats/";
+
+	private static readonly Dictionary<Type, string> MinimumValues = new()
+	{
+		{ typeof(byte), "byte.MinValue" },
+		{ typeof(sbyte), "sbyte.MinValue" },
+		{ typeof(short), "short.MinValue" },
+		{ typeof(ushort), "ushort.MinValue" },
+		{ typeof(Half), "default" },
+		{ typeof(float), "0f" },
+		{ typeof(double), "0d" },
+	};
+
+	private static readonly Dictionary<Type, string> MaximumValues = new()
+	{
+		{ typeof(byte), "byte.MaxValue" },
+		{ typeof(sbyte), "sbyte.MaxValue" },
+		{ typeof(short), "short.MaxValue" },
+		{ typeof(ushort), "ushort.MaxValue" },
+		{ typeof(Half), "(Half)1" },
+		{ typeof(float), "1f" },
+		{ typeof(double), "1d" },
+	};
+
+	private static readonly Dictionary<Type, string> TypeNames = new()
+	{
+		{ typeof(byte), "byte" },
+		{ typeof(sbyte), "sbyte" },
+		{ typeof(short), "short" },
+		{ typeof(ushort), "ushort" },
+		{ typeof(Half), "Half" },
+		{ typeof(float), "float" },
+		{ typeof(double), "double" },
+	};
+
+	private static readonly List<(string, Type, bool, bool, bool, bool)> Colors = new()
+	{
+		( "A8", typeof(byte), false, false, false, true ),
+
+		( "R8", typeof(byte), true, false, false, false ),
+		( "RG16", typeof(byte), true, true, false, false ),
+		( "RGB24", typeof(byte), true, true, true, false ),
+		( "RGBA32", typeof(byte), true, true, true, true ),
+
+		( "R8Signed", typeof(sbyte), true, false, false, false ),
+		( "RG16Signed", typeof(sbyte), true, true, false, false ),
+		( "RGB24Signed", typeof(sbyte), true, true, true, false ),
+		( "RGBA32Signed", typeof(sbyte), true, true, true, true ),
+
+		( "R16", typeof(ushort), true, false, false, false ),
+		( "RG32", typeof(ushort), true, true, false, false ),
+		( "RGB48", typeof(ushort), true, true, true, false ),
+		( "RGBA64", typeof(ushort), true, true, true, true ),
+
+		( "R16Signed", typeof(short), true, false, false, false ),
+		( "RG32Signed", typeof(short), true, true, false, false ),
+		( "RGB48Signed", typeof(short), true, true, true, false ),
+		( "RGBA64Signed", typeof(short), true, true, true, true ),
+
+		( "RHalf", typeof(Half), true, false, false, false ),
+		( "RGHalf", typeof(Half), true, true, false, false ),
+		( "RGBHalf", typeof(Half), true, true, true, false ),
+		( "RGBAHalf", typeof(Half), true, true, true, true ),
+
+		( "RSingle", typeof(float), true, false, false, false ),
+		( "RGSingle", typeof(float), true, true, false, false ),
+		( "RGBSingle", typeof(float), true, true, true, false ),
+		( "RGBASingle", typeof(float), true, true, true, true ),
+	};
+
+	static void Main()
+	{
+		foreach (var details in Colors)
+		{
+			WriteStruct(details);
+		}
+		Console.WriteLine("Done!");
+	}
+
+	private static void WriteStruct((string, Type, bool, bool, bool, bool) details)
+	{
+		string name = $"Color{details.Item1}";
+		Console.WriteLine(name);
+		using FileStream stream = File.Create($"{OutputFolder}{name}.g.cs");
+		using StreamWriter streamWriter = new StreamWriter(stream);
+		using IndentedTextWriter writer = new IndentedTextWriter(streamWriter, "\t");
+		(_, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha) = details;
+		WriteStruct(writer, name, type, hasRed, hasGreen, hasBlue, hasAlpha);
+	}
+
+	private static void WriteStruct(IndentedTextWriter writer, string name, Type type, bool hasRed, bool hasGreen, bool hasBlue, bool hasAlpha)
+	{
+		string typeName = TypeNames[type];
+		writer.WriteLine("//Auto-generated code. Do not modify.");
+		writer.WriteLine($"namespace {OutputNamespace}");
+		writer.WriteLine('{');
+		writer.Indent++;
+
+		writer.WriteLine($"public partial struct {name} : IColor<{typeName}>");
+		writer.WriteLine('{');
+		writer.Indent++;
+
+		WriteProperty(writer, hasRed, typeName, 'R', MinimumValues[type]);
+		writer.WriteLine();
+		WriteProperty(writer, hasGreen, typeName, 'G', MinimumValues[type]);
+		writer.WriteLine();
+		WriteProperty(writer, hasBlue, typeName, 'B', MinimumValues[type]);
+		writer.WriteLine();
+		WriteProperty(writer, hasAlpha, typeName, 'A', MaximumValues[type]);
+		writer.WriteLine();
+
+		WriteGetChannels(writer, typeName);
+		writer.WriteLine();
+		WriteSetChannels(writer, typeName);
+
+		writer.Indent--;
+		writer.WriteLine('}');
+
+		writer.Indent--;
+		writer.WriteLine('}');
+	}
+
+	private static void WriteGetChannels(IndentedTextWriter writer, string typeName)
+	{
+		writer.WriteLine($"public void GetChannels(out {typeName} r, out {typeName} g, out {typeName} b, out {typeName} a)");
+		writer.WriteLine('{');
+		writer.Indent++;
+		writer.WriteLine("DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);");
+		writer.Indent--;
+		writer.WriteLine('}');
+	}
+
+	private static void WriteSetChannels(IndentedTextWriter writer, string typeName)
+	{
+		writer.WriteLine($"public void SetChannels({typeName} r, {typeName} g, {typeName} b, {typeName} a)");
+		writer.WriteLine('{');
+		writer.Indent++;
+		writer.WriteLine("DefaultColorMethods.SetChannels(ref this, r, g, b, a);");
+		writer.Indent--;
+		writer.WriteLine('}');
+	}
+
+	private static void WriteProperty(IndentedTextWriter writer, bool hasColor, string typeName, char channel, string defaultValue)
+	{
+		if (hasColor)
+		{
+			writer.WriteLine($"public {typeName} {channel} {{ get; set; }}");
+		}
+		else
+		{
+			writer.WriteLine($"public {typeName} {channel} ");
+			writer.WriteLine('{');
+			writer.Indent++;
+			writer.WriteLine($"get => {defaultValue};");
+			writer.WriteLine("set { }");
+			writer.Indent--;
+			writer.WriteLine('}');
+		}
+	}
+}

AssetRipper.TextureDecoder.TestGenerator/Program.cs

@@ -15,17 +15,26 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 			new GenerationData(typeof(ColorA8), typeof(byte), 1),
 			new GenerationData(typeof(ColorARGB16), typeof(byte), 2),
 			new GenerationData(typeof(ColorARGB32), typeof(byte), 4),
+			new GenerationData(typeof(ColorBGRA32), typeof(byte), 4),
 			new GenerationData(typeof(ColorR16), typeof(ushort), 2),
+			new GenerationData(typeof(ColorR16Signed), typeof(short), 2),
 			new GenerationData(typeof(ColorR8), typeof(byte), 1),
+			new GenerationData(typeof(ColorR8Signed), typeof(sbyte), 1),
 			new GenerationData(typeof(ColorRG16), typeof(byte), 2),
+			new GenerationData(typeof(ColorRG16Signed), typeof(sbyte), 2),
 			new GenerationData(typeof(ColorRG32), typeof(ushort), 4),
+			new GenerationData(typeof(ColorRG32Signed), typeof(short), 4),
 			new GenerationData(typeof(ColorRGB16), typeof(byte), 2),
 			new GenerationData(typeof(ColorRGB24), typeof(byte), 3),
+			new GenerationData(typeof(ColorRGB24Signed), typeof(sbyte), 3),
 			new GenerationData(typeof(ColorRGB48), typeof(ushort), 6),
+			new GenerationData(typeof(ColorRGB48Signed), typeof(short), 6),
 			new GenerationData(typeof(ColorRGB9e5), typeof(double), 4),
 			new GenerationData(typeof(ColorRGBA16), typeof(byte), 2),
 			new GenerationData(typeof(ColorRGBA32), typeof(byte), 4),
+			new GenerationData(typeof(ColorRGBA32Signed), typeof(sbyte), 4),
 			new GenerationData(typeof(ColorRGBA64), typeof(ushort), 8),
+			new GenerationData(typeof(ColorRGBA64Signed), typeof(short), 8),
 			new GenerationData(typeof(ColorRGBAHalf), typeof(Half), 8),
 			new GenerationData(typeof(ColorRGBASingle), typeof(float), 16),
 			new GenerationData(typeof(ColorRGBHalf), typeof(Half), 6),
@@ -38,14 +47,16 @@ namespace AssetRipper.TextureDecoder.TestGenerator
 
 		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") },
 		};
 
-		static void Main(string[] args)
+		static void Main()
 		{
 			Directory.CreateDirectory(OutputFolder);
 

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+using AssetRipper.TextureDecoder.Rgb.Formats;
+using System.Runtime.CompilerServices;
+
+namespace AssetRipper.TextureDecoder.Tests.Formats;
+
+public partial class ColorBGRA32Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorBGRA32>(), 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 ColorBGRA32 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0b11010101,
+			G = 0b01110010,
+			B = 0b10001111,
+			A = 0b11000111,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

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

@@ -0,0 +1,155 @@
+//This code is source generated. Do not edit manually.
+
+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,
+		};
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorA8.g.cs

@@ -1,29 +1,33 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorA8 : IColor<byte>
+	public partial struct ColorA8 : IColor<byte>
 	{
-		public byte R
+		public byte R 
 		{
 			get => byte.MinValue;
 			set { }
 		}
-		public byte G
+		
+		public byte G 
 		{
 			get => byte.MinValue;
 			set { }
 		}
-		public byte B
+		
+		public byte B 
 		{
 			get => byte.MinValue;
 			set { }
 		}
+		
 		public byte A { get; set; }
-
+		
 		public void GetChannels(out byte r, out byte g, out byte b, out byte a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(byte r, byte g, byte b, byte a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorR16.g.cs

@@ -1,29 +1,33 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorR16 : IColor<ushort>
+	public partial struct ColorR16 : IColor<ushort>
 	{
 		public ushort R { get; set; }
-		public ushort G
+		
+		public ushort G 
 		{
 			get => ushort.MinValue;
 			set { }
 		}
-		public ushort B
+		
+		public ushort B 
 		{
 			get => ushort.MinValue;
 			set { }
 		}
-		public ushort A
+		
+		public ushort A 
 		{
 			get => ushort.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorR16Signed.g.cs

@@ -0,0 +1,36 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorR16Signed : IColor<short>
+	{
+		public short R { get; set; }
+		
+		public short G 
+		{
+			get => short.MinValue;
+			set { }
+		}
+		
+		public short B 
+		{
+			get => short.MinValue;
+			set { }
+		}
+		
+		public short A 
+		{
+			get => short.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out short r, out short g, out short b, out short a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(short r, short g, short b, short a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorR8.g.cs

@@ -1,29 +1,33 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorR8 : IColor<byte>
+	public partial struct ColorR8 : IColor<byte>
 	{
 		public byte R { get; set; }
-		public byte G
+		
+		public byte G 
 		{
 			get => byte.MinValue;
 			set { }
 		}
-		public byte B
+		
+		public byte B 
 		{
 			get => byte.MinValue;
 			set { }
 		}
-		public byte A
+		
+		public byte A 
 		{
 			get => byte.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out byte r, out byte g, out byte b, out byte a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(byte r, byte g, byte b, byte a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorR8Signed.g.cs

@@ -0,0 +1,36 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorR8Signed : IColor<sbyte>
+	{
+		public sbyte R { get; set; }
+		
+		public sbyte G 
+		{
+			get => sbyte.MinValue;
+			set { }
+		}
+		
+		public sbyte B 
+		{
+			get => sbyte.MinValue;
+			set { }
+		}
+		
+		public sbyte A 
+		{
+			get => sbyte.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16.g.cs

@@ -1,25 +1,29 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRG16 : IColor<byte>
+	public partial struct ColorRG16 : IColor<byte>
 	{
 		public byte R { get; set; }
+		
 		public byte G { get; set; }
-		public byte B
+		
+		public byte B 
 		{
 			get => byte.MinValue;
 			set { }
 		}
-		public byte A
+		
+		public byte A 
 		{
 			get => byte.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out byte r, out byte g, out byte b, out byte a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(byte r, byte g, byte b, byte a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRG16Signed.g.cs

@@ -0,0 +1,32 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorRG16Signed : IColor<sbyte>
+	{
+		public sbyte R { get; set; }
+		
+		public sbyte G { get; set; }
+		
+		public sbyte B 
+		{
+			get => sbyte.MinValue;
+			set { }
+		}
+		
+		public sbyte A 
+		{
+			get => sbyte.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32.g.cs

@@ -1,25 +1,29 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRG32 : IColor<ushort>
+	public partial struct ColorRG32 : IColor<ushort>
 	{
 		public ushort R { get; set; }
+		
 		public ushort G { get; set; }
-		public ushort B
+		
+		public ushort B 
 		{
 			get => ushort.MinValue;
 			set { }
 		}
-		public ushort A
+		
+		public ushort A 
 		{
 			get => ushort.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRG32Signed.g.cs

@@ -0,0 +1,32 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorRG32Signed : IColor<short>
+	{
+		public short R { get; set; }
+		
+		public short G { get; set; }
+		
+		public short B 
+		{
+			get => short.MinValue;
+			set { }
+		}
+		
+		public short A 
+		{
+			get => short.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out short r, out short g, out short b, out short a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(short r, short g, short b, short a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24.g.cs

@@ -1,21 +1,25 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGB24 : IColor<byte>
+	public partial struct ColorRGB24 : IColor<byte>
 	{
 		public byte R { get; set; }
+		
 		public byte G { get; set; }
+		
 		public byte B { get; set; }
-		public byte A
+		
+		public byte A 
 		{
 			get => byte.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out byte r, out byte g, out byte b, out byte a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(byte r, byte g, byte b, byte a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB24Signed.g.cs

@@ -0,0 +1,28 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorRGB24Signed : IColor<sbyte>
+	{
+		public sbyte R { get; set; }
+		
+		public sbyte G { get; set; }
+		
+		public sbyte B { get; set; }
+		
+		public sbyte A 
+		{
+			get => sbyte.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48.g.cs

@@ -1,21 +1,25 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGB48 : IColor<ushort>
+	public partial struct ColorRGB48 : IColor<ushort>
 	{
 		public ushort R { get; set; }
+		
 		public ushort G { get; set; }
+		
 		public ushort B { get; set; }
-		public ushort A
+		
+		public ushort A 
 		{
 			get => ushort.MaxValue;
 			set { }
 		}
-
+		
 		public void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGB48Signed.g.cs

@@ -0,0 +1,28 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorRGB48Signed : IColor<short>
+	{
+		public short R { get; set; }
+		
+		public short G { get; set; }
+		
+		public short B { get; set; }
+		
+		public short A 
+		{
+			get => short.MaxValue;
+			set { }
+		}
+		
+		public void GetChannels(out short r, out short g, out short b, out short a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(short r, short g, short b, short a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32.g.cs

@@ -1,17 +1,21 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGBA32 : IColor<byte>
+	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 void GetChannels(out byte r, out byte g, out byte b, out byte a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(byte r, byte g, byte b, byte a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA32Signed.g.cs

@@ -0,0 +1,24 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	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 void GetChannels(out sbyte r, out sbyte g, out sbyte b, out sbyte a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(sbyte r, sbyte g, sbyte b, sbyte a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64.g.cs

@@ -1,17 +1,21 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGBA64 : IColor<ushort>
+	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 void GetChannels(out ushort r, out ushort g, out ushort b, out ushort a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(ushort r, ushort g, ushort b, ushort a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBA64Signed.g.cs

@@ -0,0 +1,24 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	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 void GetChannels(out short r, out short g, out short b, out short a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(short r, short g, short b, short a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBAHalf.g.cs

@@ -1,17 +1,21 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGBAHalf : IColor<Half>
+	public partial struct ColorRGBAHalf : IColor<Half>
 	{
 		public Half R { get; set; }
+		
 		public Half G { get; set; }
+		
 		public Half B { get; set; }
+		
 		public Half A { get; set; }
-
+		
 		public 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)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBASingle.cs

@@ -1,20 +0,0 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
-{
-    public struct ColorRGBASingle : IColor<float>
-    {
-        public float R { get; set; }
-        public float G { get; set; }
-        public float B { get; set; }
-        public float A { get; set; }
-
-        public void GetChannels(out float r, out float g, out float b, out float a)
-        {
-            DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
-        }
-
-        public void SetChannels(float r, float g, float b, float a)
-        {
-            DefaultColorMethods.SetChannels(ref this, r, g, b, a);
-        }
-    }
-}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBASingle.g.cs

@@ -0,0 +1,24 @@
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public partial struct ColorRGBASingle : IColor<float>
+	{
+		public float R { get; set; }
+		
+		public float G { get; set; }
+		
+		public float B { get; set; }
+		
+		public float A { get; set; }
+		
+		public void GetChannels(out float r, out float g, out float b, out float a)
+		{
+			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
+		}
+		
+		public void SetChannels(float r, float g, float b, float a)
+		{
+			DefaultColorMethods.SetChannels(ref this, r, g, b, a);
+		}
+	}
+}

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBHalf.g.cs

@@ -1,21 +1,25 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGBHalf : IColor<Half>
+	public partial struct ColorRGBHalf : IColor<Half>
 	{
 		public Half R { get; set; }
+		
 		public Half G { get; set; }
+		
 		public Half B { get; set; }
-		public Half A
+		
+		public Half A 
 		{
 			get => (Half)1;
 			set { }
 		}
-
+		
 		public 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)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGBSingle.g.cs

@@ -1,21 +1,25 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGBSingle : IColor<float>
+	public partial struct ColorRGBSingle : IColor<float>
 	{
 		public float R { get; set; }
+		
 		public float G { get; set; }
+		
 		public float B { get; set; }
-		public float A
+		
+		public float A 
 		{
-			get => 1;
+			get => 1f;
 			set { }
 		}
-
+		
 		public void GetChannels(out float r, out float g, out float b, out float a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(float r, float g, float b, float a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGHalf.g.cs

@@ -1,25 +1,29 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGHalf : IColor<Half>
+	public partial struct ColorRGHalf : IColor<Half>
 	{
 		public Half R { get; set; }
+		
 		public Half G { get; set; }
-		public Half B
+		
+		public Half B 
 		{
 			get => default;
 			set { }
 		}
-		public Half A
+		
+		public Half A 
 		{
 			get => (Half)1;
 			set { }
 		}
-
+		
 		public 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)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRGSingle.g.cs

@@ -1,25 +1,29 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRGSingle : IColor<float>
+	public partial struct ColorRGSingle : IColor<float>
 	{
 		public float R { get; set; }
+		
 		public float G { get; set; }
-		public float B
+		
+		public float B 
 		{
-			get => default;
+			get => 0f;
 			set { }
 		}
-		public float A
+		
+		public float A 
 		{
-			get => 1;
+			get => 1f;
 			set { }
 		}
-
+		
 		public void GetChannels(out float r, out float g, out float b, out float a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(float r, float g, float b, float a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRHalf.g.cs

@@ -1,29 +1,33 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRHalf : IColor<Half>
+	public partial struct ColorRHalf : IColor<Half>
 	{
 		public Half R { get; set; }
-		public Half G
+		
+		public Half G 
 		{
 			get => default;
 			set { }
 		}
-		public Half B
+		
+		public Half B 
 		{
 			get => default;
 			set { }
 		}
-		public Half A
+		
+		public Half A 
 		{
 			get => (Half)1;
 			set { }
 		}
-
+		
 		public 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)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

AssetRipper.TextureDecoder/Rgb/Formats/ColorRSingle.g.cs

@@ -1,29 +1,33 @@
-namespace AssetRipper.TextureDecoder.Rgb.Formats
+//Auto-generated code. Do not modify.
+namespace AssetRipper.TextureDecoder.Rgb.Formats
 {
-	public struct ColorRSingle : IColor<float>
+	public partial struct ColorRSingle : IColor<float>
 	{
 		public float R { get; set; }
-		public float G
+		
+		public float G 
 		{
-			get => default;
+			get => 0f;
 			set { }
 		}
-		public float B
+		
+		public float B 
 		{
-			get => default;
+			get => 0f;
 			set { }
 		}
-		public float A
+		
+		public float A 
 		{
-			get => 1;
+			get => 1f;
 			set { }
 		}
-
+		
 		public void GetChannels(out float r, out float g, out float b, out float a)
 		{
 			DefaultColorMethods.GetChannels(this, out r, out g, out b, out a);
 		}
-
+		
 		public void SetChannels(float r, float g, float b, float a)
 		{
 			DefaultColorMethods.SetChannels(ref this, r, g, b, a);

TextureDecoder.sln

@@ -31,6 +31,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssetRipper.TextureDecoder.
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssetRipper.TextureDecoder.Benchmarks", "AssetRipper.TextureDecoder.Benchmarks\AssetRipper.TextureDecoder.Benchmarks.csproj", "{F85804F4-4864-412E-BDC6-8B6E2B5646A7}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssetRipper.TextureDecoder.ColorGenerator", "AssetRipper.TextureDecoder.ColorGenerator\AssetRipper.TextureDecoder.ColorGenerator.csproj", "{E9ED1120-1CEA-433E-9BFF-C4B20A34CC7B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -57,6 +59,10 @@ Global
 		{F85804F4-4864-412E-BDC6-8B6E2B5646A7}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F85804F4-4864-412E-BDC6-8B6E2B5646A7}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F85804F4-4864-412E-BDC6-8B6E2B5646A7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E9ED1120-1CEA-433E-9BFF-C4B20A34CC7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E9ED1120-1CEA-433E-9BFF-C4B20A34CC7B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E9ED1120-1CEA-433E-9BFF-C4B20A34CC7B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E9ED1120-1CEA-433E-9BFF-C4B20A34CC7B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE