new rgb conversion code

AssetRipper.TextureDecoder.Tests/Formats/ColorA8Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorARGB16Tests.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 ColorARGB16Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorARGB16>(), 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 ColorARGB16 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0b11010101,
+			G = 0b01110010,
+			B = 0b10001111,
+			A = 0b11000111,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorARGB32Tests.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 ColorARGB32Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorARGB32>(), 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 ColorARGB32 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0b11010101,
+			G = 0b01110010,
+			B = 0b10001111,
+			A = 0b11000111,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorR16Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorR8Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRG16Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRG32Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB16Tests.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 ColorRGB16Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGB16>(), 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 ColorRGB16 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0b11010101,
+			G = 0b01110010,
+			B = 0b10001111,
+			A = 0b11000111,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB24Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB48Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGB9e5Tests.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 ColorRGB9e5Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGB9e5>(), 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 ColorRGB9e5 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0.447f,
+			G = 0.224f,
+			B = 0.95f,
+			A = 0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA16Tests.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 ColorRGBA16Tests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGBA16>(), 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 ColorRGBA16 MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0b11010101,
+			G = 0b01110010,
+			B = 0b10001111,
+			A = 0b11000111,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA32Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBA64Tests.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 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,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBAHalfTests.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 ColorRGBAHalfTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGBAHalf>(), 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 ColorRGBAHalf MakeRandomColor()
+	{
+		return new()
+		{
+			R = (Half)0.447f,
+			G = (Half)0.224f,
+			B = (Half)0.95f,
+			A = (Half)0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGBASingleTests.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 ColorRGBASingleTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGBASingle>(), 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 ColorRGBASingle MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0.447f,
+			G = 0.224f,
+			B = 0.95f,
+			A = 0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGHalfTests.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 ColorRGHalfTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGHalf>(), 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 ColorRGHalf MakeRandomColor()
+	{
+		return new()
+		{
+			R = (Half)0.447f,
+			G = (Half)0.224f,
+			B = (Half)0.95f,
+			A = (Half)0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRGSingleTests.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 ColorRGSingleTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRGSingle>(), 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 ColorRGSingle MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0.447f,
+			G = 0.224f,
+			B = 0.95f,
+			A = 0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRHalfTests.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 ColorRHalfTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRHalf>(), 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 ColorRHalf MakeRandomColor()
+	{
+		return new()
+		{
+			R = (Half)0.447f,
+			G = (Half)0.224f,
+			B = (Half)0.95f,
+			A = (Half)0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/Formats/ColorRSingleTests.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 ColorRSingleTests
+{
+	[Test]
+	public void CorrectSizeTest()
+	{
+		Assert.That(Unsafe.SizeOf<ColorRSingle>(), 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 ColorRSingle MakeRandomColor()
+	{
+		return new()
+		{
+			R = 0.447f,
+			G = 0.224f,
+			B = 0.95f,
+			A = 0.897f,
+		};
+	}
+}

AssetRipper.TextureDecoder.Tests/NewRgbTests.cs

@@ -0,0 +1,245 @@
+using AssetRipper.TextureDecoder.Rgb;
+using AssetRipper.TextureDecoder.Rgb.Formats;
+
+namespace AssetRipper.TextureDecoder.Tests
+{
+	public sealed class NewRgbTests
+	{
+		[Test]
+		public void ConvertA8Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.alpha8");
+			int totalBytesRead = 0;
+			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);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+		}
+
+		[Test]
+		public void ConvertARGB16Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.argb4444");
+			int totalBytesRead = 0;
+			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
+			{
+				int bytesRead = RgbConverter.ARGB16ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
+				RgbConverter.Convert<ColorARGB16, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+		}
+
+		[Test]
+		public void ConvertRGB24Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgb24");
+			int totalBytesRead = 0;
+			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);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+		}
+
+		[Test]
+		public void ConvertRGBA32Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgba32");
+			int totalBytesRead = 0;
+			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);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertARGB32Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.argb32");
+			int totalBytesRead = 0;
+			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
+			{
+				int bytesRead = RgbConverter.ARGB32ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
+				RgbConverter.Convert<ColorARGB32, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertRGB16Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgb565");
+			int totalBytesRead = 0;
+			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
+			{
+				int bytesRead = RgbConverter.RGB16ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
+				RgbConverter.Convert<ColorRGB16, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertR16Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.r16");
+			int totalBytesRead = 0;
+			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
+			{
+				int bytesRead = RgbConverter.R16ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
+				RgbConverter.Convert<ColorR16, ushort, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertRGBA16Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgba4444");
+			int totalBytesRead = 0;
+			foreach (int size in new int[] { 256, 128, 64, 32, 16, 8, 4, 2, 1 }) //mip maps
+			{
+				int bytesRead = RgbConverter.RGBA16ToBGRA32(data.Slice(totalBytesRead), size, size, out byte[] originalDecodedData);
+				RgbConverter.Convert<ColorRGBA16, byte, ColorBGRA32, byte>(data.Slice(totalBytesRead), size, size, out byte[] newDecodedData);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertRG16Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rg16");
+			int totalBytesRead = 0;
+			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);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertR8Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.r8");
+			int totalBytesRead = 0;
+			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);
+				totalBytesRead += bytesRead;
+				Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+			}
+			Assert.That(totalBytesRead, Is.EqualTo(data.Length));
+		}
+
+		[Test]
+		public void ConvertRHalfTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rhalf");
+			RgbConverter.RHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRHalf, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGHalfTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rghalf");
+			RgbConverter.RGHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGHalf, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGBAHalfTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgbahalf");
+			RgbConverter.RGBAHalfToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGBAHalf, Half, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRFloatTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rfloat");
+			RgbConverter.RFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRSingle, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGFloatTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgfloat");
+			RgbConverter.RGFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGSingle, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGBAFloatTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgbafloat");
+			RgbConverter.RGBAFloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGBASingle, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGB9e5FloatTest()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgb9e5float");
+			RgbConverter.RGB9e5FloatToBGRA32(data, 256, 256, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGB9e5, float, ColorBGRA32, byte>(data, 256, 256, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRG32Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rg32");
+			RgbConverter.RG32ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRG32, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGB48Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgb48");
+			RgbConverter.RGB48ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGB48, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+
+		[Test]
+		public void ConvertRGBA64Test()
+		{
+			ReadOnlySpan<byte> data = File.ReadAllBytes(PathConstants.RgbTestProjectRootFolder + "test.rgba64");
+			RgbConverter.RGBA64ToBGRA32(data, 512, 512, out byte[] originalDecodedData);
+			RgbConverter.Convert<ColorRGBA64, ushort, ColorBGRA32, byte>(data, 512, 512, out byte[] newDecodedData);
+			Assert.That(originalDecodedData, Is.EqualTo(newDecodedData));
+		}
+	}
+}

TestSourceGenerator/ColorRandomValues.cs

@@ -0,0 +1,20 @@
+namespace TestSourceGenerator
+{
+	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;
+		}
+	}
+}

TestSourceGenerator/GenerationData.cs

@@ -0,0 +1,16 @@
+namespace TestSourceGenerator
+{
+	internal struct GenerationData
+	{
+		public Type ColorType;
+		public Type ChannelType;
+		public int ColorSize;
+
+		public GenerationData(Type colorType, Type channelType, int colorSize)
+		{
+			ColorType = colorType;
+			ChannelType = channelType;
+			ColorSize = colorSize;
+		}
+	}
+}

TestSourceGenerator/Program.cs

@@ -0,0 +1,264 @@
+using AssetRipper.TextureDecoder.Rgb.Formats;
+using System.CodeDom.Compiler;
+
+namespace TestSourceGenerator
+{
+	internal static class Program
+	{
+		private const string OutputNamespace = "AssetRipper.TextureDecoder.Tests.Formats";
+		private const string OutputFolder = "../../../../AssetRipper.TextureDecoder.Tests/Formats/";
+
+		private static readonly char[] channels = new char[] { 'R', 'G', 'B', 'A' };
+
+		private static readonly List<GenerationData> dataList = new()
+		{
+			new GenerationData(typeof(ColorA8), typeof(byte), 1),
+			new GenerationData(typeof(ColorARGB16), typeof(byte), 2),
+			new GenerationData(typeof(ColorARGB32), typeof(byte), 4),
+			new GenerationData(typeof(ColorR16), typeof(ushort), 2),
+			new GenerationData(typeof(ColorR8), typeof(byte), 1),
+			new GenerationData(typeof(ColorRG16), typeof(byte), 2),
+			new GenerationData(typeof(ColorRG32), typeof(ushort), 4),
+			new GenerationData(typeof(ColorRGB16), typeof(byte), 2),
+			new GenerationData(typeof(ColorRGB24), typeof(byte), 3),
+			new GenerationData(typeof(ColorRGB48), typeof(ushort), 6),
+			new GenerationData(typeof(ColorRGB9e5), typeof(float), 4),
+			new GenerationData(typeof(ColorRGBA16), typeof(byte), 2),
+			new GenerationData(typeof(ColorRGBA32), typeof(byte), 4),
+			new GenerationData(typeof(ColorRGBA64), typeof(ushort), 8),
+			new GenerationData(typeof(ColorRGBAHalf), typeof(Half), 8),
+			new GenerationData(typeof(ColorRGBASingle), typeof(float), 16),
+			new GenerationData(typeof(ColorRGHalf), typeof(Half), 4),
+			new GenerationData(typeof(ColorRGSingle), typeof(float), 8),
+			new GenerationData(typeof(ColorRHalf), typeof(Half), 2),
+			new GenerationData(typeof(ColorRSingle), typeof(float), 4),
+		};
+
+		private static readonly Dictionary<Type, ColorRandomValues> randomValueDictionary = new()
+		{
+			{ typeof(byte), new ColorRandomValues("0b11010101", "0b01110010", "0b10001111", "0b11000111", "0b01001110") },
+			{ 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") }
+		};
+
+		static void Main(string[] args)
+		{
+			Directory.CreateDirectory(OutputFolder);
+
+			foreach (GenerationData data in dataList)
+			{
+				using MemoryStream memoryStream = new();
+				using StreamWriter streamWriter = new StreamWriter(memoryStream);
+				using IndentedTextWriter textWriter = new IndentedTextWriter(streamWriter, "\t");
+				textWriter.NewLine = "\r\n";
+
+				textWriter.WriteSourceGenerationDisclaimer();
+				textWriter.WriteNamespaceUsings(data);
+				textWriter.WriteFileScopedNamespace();
+				textWriter.WriteClassDefinitionOpen(data);
+				textWriter.Indent += 1;
+
+				textWriter.WriteCorrectSizeTest(data);
+				textWriter.WriteLine();
+				textWriter.WritePropertySymmetryTests(data);
+				textWriter.WriteIndependenceTests(data);
+				textWriter.WriteGetMethodMatchesProperties();
+				textWriter.WriteLine();
+				textWriter.WriteMethodSymmetryTest();
+				textWriter.WriteLine();
+				textWriter.WriteMakeRandomColor(data);
+
+				textWriter.Indent -= 1;
+				textWriter.WriteClassDefinitionClose();
+
+				textWriter.Flush();
+				streamWriter.Flush();
+
+				string outputFilePath = $"{OutputFolder}{data.ColorType.Name}Tests.g.cs";
+				File.WriteAllBytes(outputFilePath, memoryStream.ToArray());
+				Console.WriteLine(outputFilePath);
+			}
+
+			Console.WriteLine("Done!");
+		}
+
+		private static void WriteNamespaceUsings(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			textWriter.WriteLine($"using {data.ColorType.Namespace};");
+			textWriter.WriteLine($"using {typeof(System.Runtime.CompilerServices.Unsafe).Namespace};");
+			textWriter.WriteLine();//An empty line after the usings
+		}
+
+		private static void WriteFileScopedNamespace(this IndentedTextWriter textWriter)
+		{
+			textWriter.WriteLine($"namespace {OutputNamespace};");
+			textWriter.WriteLine();//An empty line after the namespace declaration
+		}
+
+		private static void WriteSourceGenerationDisclaimer(this IndentedTextWriter textWriter)
+		{
+			textWriter.WriteLine($"//This code is source generated. Do not edit manually.");
+			textWriter.WriteLine();
+		}
+
+		private static void WriteClassDefinitionOpen(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			textWriter.WriteLine($"public partial class {data.ColorType.Name}Tests");
+			textWriter.WriteLine("{");
+		}
+
+		private static void WriteClassDefinitionClose(this IndentedTextWriter textWriter)
+		{
+			textWriter.WriteLine("}");
+		}
+
+		private static void WriteCorrectSizeTest(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine("public void CorrectSizeTest()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+			textWriter.WriteLine($"Assert.That(Unsafe.SizeOf<{data.ColorType.Name}>(), Is.EqualTo({data.ColorSize}));");
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
+
+		private static void WriteMakeRandomColor(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			textWriter.WriteLine($"public static {data.ColorType.Name} MakeRandomColor()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			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 WritePropertySymmetryTests(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			foreach(char channel in channels)
+			{
+				textWriter.WritePropertySymmetryTest(data, channel);
+				textWriter.WriteLine();
+			}
+		}
+
+		private static void WritePropertySymmetryTest(this IndentedTextWriter textWriter, GenerationData data, char channel)
+		{
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine($"public void PropertyIsSymmetric_{channel}()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+			textWriter.WriteLine("var color = MakeRandomColor();");
+			char variableName = char.ToLowerInvariant(channel);
+			textWriter.WriteLine($"var {variableName} = color.{channel};");
+			textWriter.WriteLine($"color.{channel} = {variableName};");
+			textWriter.WriteLine($"Assert.That(color.{channel}, Is.EqualTo({variableName}));");
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
+
+		private static void WriteIndependenceTests(this IndentedTextWriter textWriter, GenerationData data)
+		{
+			foreach (char channel in channels)
+			{
+				textWriter.WriteIndependenceTest(data, channel);
+				textWriter.WriteLine();
+			}
+		}
+
+		private static void WriteIndependenceTest(this IndentedTextWriter textWriter, GenerationData data, char channel)
+		{
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine($"public void ChannelsAreIndependent_{channel}()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			textWriter.WriteLine("var color = MakeRandomColor();");
+			foreach(char otherChannel in channels.Where(c => c != channel))
+			{
+				textWriter.WriteLine($"var {char.ToLowerInvariant(otherChannel)} = color.{otherChannel};");
+			}
+			textWriter.WriteLine($"color.{channel} = {randomValueDictionary[data.ChannelType].SetValue};");
+
+			textWriter.WriteLine("Assert.Multiple(() =>");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			foreach (char otherChannel in channels.Where(c => c != channel))
+			{
+				textWriter.WriteLine($"Assert.That(color.{otherChannel}, Is.EqualTo({char.ToLowerInvariant(otherChannel)}));");
+			}
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("});");
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
+
+		private static void WriteGetMethodMatchesProperties(this IndentedTextWriter textWriter)
+		{
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine($"public void GetMethodMatchesProperties()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			textWriter.WriteLine("var color = MakeRandomColor();");
+			textWriter.WriteLine("color.GetChannels(out var r, out var g, out var b, out var a);");
+			textWriter.WriteLine("Assert.Multiple(() =>");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			foreach (char channel in channels)
+			{
+				textWriter.WriteLine($"Assert.That(color.{channel}, Is.EqualTo({char.ToLowerInvariant(channel)}));");
+			}
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("});");
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
+
+		private static void WriteMethodSymmetryTest(this IndentedTextWriter textWriter)
+		{
+			textWriter.WriteLine("[Test]");
+			textWriter.WriteLine($"public void MethodsAreSymmetric()");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			textWriter.WriteLine("var color = MakeRandomColor();");
+			textWriter.WriteLine("color.GetChannels(out var r, out var g, out var b, out var a);");
+			textWriter.WriteLine("color.SetChannels(r, g, b, a);");
+			textWriter.WriteLine("Assert.Multiple(() =>");
+			textWriter.WriteLine("{");
+			textWriter.Indent += 1;
+
+			foreach (char channel in channels)
+			{
+				textWriter.WriteLine($"Assert.That(color.{channel}, Is.EqualTo({char.ToLowerInvariant(channel)}));");
+			}
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("});");
+
+			textWriter.Indent -= 1;
+			textWriter.WriteLine("}");
+		}
+	}
+}

TestSourceGenerator/TestSourceGenerator.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\TextureDecoder\TextureDecoder.csproj" />
+  </ItemGroup>
+
+</Project>

TextureDecoder.sln

@@ -36,7 +36,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Licenses", "Licenses", "{0B
 		Licenses\uTinyRipper.md = Licenses\uTinyRipper.md
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssetRipper.TextureDecoder.Tests", "AssetRipper.TextureDecoder.Tests\AssetRipper.TextureDecoder.Tests.csproj", "{30E8E8F4-2CE4-4435-A49F-C5AF91D58FFE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssetRipper.TextureDecoder.Tests", "AssetRipper.TextureDecoder.Tests\AssetRipper.TextureDecoder.Tests.csproj", "{30E8E8F4-2CE4-4435-A49F-C5AF91D58FFE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestSourceGenerator", "TestSourceGenerator\TestSourceGenerator.csproj", "{F13DB418-1E43-43CA-B85C-A46E911FC906}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -80,6 +82,10 @@ Global
 		{30E8E8F4-2CE4-4435-A49F-C5AF91D58FFE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{30E8E8F4-2CE4-4435-A49F-C5AF91D58FFE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{30E8E8F4-2CE4-4435-A49F-C5AF91D58FFE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F13DB418-1E43-43CA-B85C-A46E911FC906}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F13DB418-1E43-43CA-B85C-A46E911FC906}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F13DB418-1E43-43CA-B85C-A46E911FC906}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F13DB418-1E43-43CA-B85C-A46E911FC906}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

TextureDecoder/Rgb/ConversionUtilities.cs

@@ -0,0 +1,153 @@
+using System.Runtime.CompilerServices;
+
+namespace AssetRipper.TextureDecoder.Rgb
+{
+	internal static class ConversionUtilities
+	{
+		internal static TTo ConvertValue<TFrom, TTo>(TFrom value)
+			where TFrom : unmanaged
+			where TTo : unmanaged
+		{
+			if (typeof(TFrom) == typeof(byte))
+			{
+				return ConvertUInt8<TTo>(Unsafe.As<TFrom, byte>(ref value));
+			}
+			else if (typeof(TFrom) == typeof(ushort))
+			{
+				return ConvertUInt16<TTo>(Unsafe.As<TFrom, ushort>(ref value));
+			}
+			else if (typeof(TFrom) == typeof(Half))
+			{
+				return ConvertHalf<TTo>(Unsafe.As<TFrom, Half>(ref value));
+			}
+			else if (typeof(TFrom) == typeof(float))
+			{
+				return ConvertSingle<TTo>(Unsafe.As<TFrom, float>(ref value));
+			}
+			else
+			{
+				return default; //exceptions prevent inlining
+			}
+		}
+
+		private static TTo ConvertUInt8<TTo>(byte value) where TTo : unmanaged
+		{
+			if (typeof(TTo) == typeof(byte))
+			{
+				return Unsafe.As<byte, TTo>(ref value);
+			}
+			else if (typeof(TTo) == typeof(ushort))
+			{
+				ushort converted = unchecked((ushort)((uint)value << 8));
+				return Unsafe.As<ushort, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(Half))
+			{
+				Half converted = (Half)(value / (float)byte.MaxValue);
+				return Unsafe.As<Half, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(float))
+			{
+				float converted = (float)(value / (float)byte.MaxValue);
+				return Unsafe.As<float, TTo>(ref converted);
+			}
+			else
+			{
+				return default; //exceptions prevent inlining
+			}
+		}
+
+		private static TTo ConvertUInt16<TTo>(ushort value) where TTo : unmanaged
+		{
+			if (typeof(TTo) == typeof(byte))
+			{
+				byte converted = unchecked((byte)((uint)value >> 8));
+				return Unsafe.As<byte, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(ushort))
+			{
+				return Unsafe.As<ushort, TTo>(ref value);
+			}
+			else if (typeof(TTo) == typeof(Half))
+			{
+				Half converted = (Half)(value / (float)ushort.MaxValue);
+				return Unsafe.As<Half, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(float))
+			{
+				float converted = (float)(value / (float)ushort.MaxValue);
+				return Unsafe.As<float, TTo>(ref converted);
+			}
+			else
+			{
+				return default; //exceptions prevent inlining
+			}
+		}
+
+		private static TTo ConvertHalf<TTo>(Half value) where TTo : unmanaged
+		{
+			if (typeof(TTo) == typeof(byte))
+			{
+				byte converted = ClampByte((float)value * byte.MaxValue);
+				return Unsafe.As<byte, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(ushort))
+			{
+				ushort converted = ClampUInt16((float)value * ushort.MaxValue);
+				return Unsafe.As<ushort, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(Half))
+			{
+				return Unsafe.As<Half, TTo>(ref value);
+			}
+			else if (typeof(TTo) == typeof(float))
+			{
+				float converted = (float)value;
+				return Unsafe.As<float, TTo>(ref converted);
+			}
+			else
+			{
+				return default; //exceptions prevent inlining
+			}
+		}
+
+		private static TTo ConvertSingle<TTo>(float value) where TTo : unmanaged
+		{
+			if (typeof(TTo) == typeof(byte))
+			{
+				byte converted = ClampByte(value * byte.MaxValue);
+				return Unsafe.As<byte, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(ushort))
+			{
+				ushort converted = ClampUInt16(value * ushort.MaxValue);
+				return Unsafe.As<ushort, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(Half))
+			{
+				Half converted = (Half)value;
+				return Unsafe.As<Half, TTo>(ref converted);
+			}
+			else if (typeof(TTo) == typeof(float))
+			{
+				return Unsafe.As<float, TTo>(ref value);
+			}
+			else
+			{
+				return default; //exceptions prevent inlining
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static byte ClampByte(float x)
+		{
+			return byte.MaxValue < x ? byte.MaxValue : (x > byte.MinValue ? (byte)x : byte.MinValue);
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static ushort ClampUInt16(float x)
+		{
+			return ushort.MaxValue < x ? ushort.MaxValue : (x > ushort.MinValue ? (ushort)x : ushort.MinValue);
+		}
+	}
+}

TextureDecoder/Rgb/DefaultColorMethods.cs

@@ -0,0 +1,25 @@
+namespace AssetRipper.TextureDecoder.Rgb
+{
+	internal static class DefaultColorMethods
+	{
+		internal static void GetChannels<T, TArg>(T color, out TArg r, out TArg g, out TArg b, out TArg a)
+			where TArg : unmanaged
+			where T : unmanaged, IColor<TArg>
+		{
+			r = color.R;
+			g = color.G;
+			b = color.B;
+			a = color.A;
+		}
+
+		internal static void SetChannels<T, TArg>(ref T color, TArg r, TArg g, TArg b, TArg a)
+			where TArg : unmanaged
+			where T : unmanaged, IColor<TArg>
+		{
+			color.R = r;
+			color.G = g;
+			color.B = b;
+			color.A = a;
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorA8.cs

@@ -0,0 +1,32 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorA8 : IColor<byte>
+	{
+		public byte R
+		{
+			get => byte.MinValue;
+			set { }
+		}
+		public byte G
+		{
+			get => byte.MinValue;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorARGB16.cs

@@ -0,0 +1,39 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorARGB16 : IColor<byte>
+	{
+		private byte gb;
+		private byte ar;
+
+		public byte B
+		{
+			get => unchecked((byte)((uint)gb << 4));
+			set => gb = unchecked((byte)(((uint)value >> 4) | (gb & 0xF0u)));
+		}
+		public byte G
+		{
+			get => (byte)(gb & 0xF0);
+			set => gb = (byte)((value & 0xF0u) | (gb & 0x0Fu));
+		}
+		public byte R
+		{
+			get => unchecked((byte)(ar << 4));
+			set => ar = unchecked((byte)(((uint)value >> 4) | (ar & 0xF0u)));
+		}
+		public byte A
+		{
+			get => (byte)(ar & 0xF0);
+			set => ar = (byte)((value & 0xF0u) | (ar & 0x0Fu));
+		}
+
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorARGB32.cs

@@ -0,0 +1,20 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorARGB32 : IColor<byte>
+	{
+		public byte A { get; set; }
+		public byte R { get; set; }
+		public byte G { get; set; }
+		public byte B { 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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorBGRA32.cs

@@ -0,0 +1,20 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorBGRA32 : IColor<byte>
+	{
+		public byte B { get; set; }
+		public byte G { get; set; }
+		public byte R { 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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorR16.cs

@@ -0,0 +1,32 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorR16 : IColor<ushort>
+	{
+		public ushort R { get; set; }
+		public ushort G
+		{
+			get => ushort.MinValue;
+			set { }
+		}
+		public ushort B
+		{
+			get => ushort.MinValue;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorR8.cs

@@ -0,0 +1,32 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorR8 : IColor<byte>
+	{
+		public byte R { get; set; }
+		public byte G
+		{
+			get => byte.MinValue;
+			set { }
+		}
+		public byte B
+		{
+			get => byte.MinValue;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRG16.cs

@@ -0,0 +1,28 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRG16 : IColor<byte>
+	{
+		public byte R { get; set; }
+		public byte G { get; set; }
+		public byte B
+		{
+			get => byte.MinValue;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRG32.cs

@@ -0,0 +1,28 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRG32 : IColor<ushort>
+	{
+		public ushort R { get; set; }
+		public ushort G { get; set; }
+		public ushort B
+		{
+			get => ushort.MinValue;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGB16.cs

@@ -0,0 +1,62 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	/// <summary>
+	/// Also called RGB 565
+	/// </summary>
+	public struct ColorRGB16 : IColor<byte>
+	{
+		private ushort bits;
+
+		/// <summary>
+		/// 5 bits
+		/// </summary>
+		public byte R
+		{
+			get => (byte)(((uint)bits >> 8) & 0xF8);
+			set
+			{
+				bits = (ushort)((((uint)value << 8) & 0xF800u) | (bits & ~0xF800u));
+			}
+		}
+
+		/// <summary>
+		/// 6 bits
+		/// </summary>
+		public byte G
+		{
+			get => (byte)(((uint)bits >> 3) & 0xFC);
+			set
+			{
+				bits = (ushort)((((uint)value << 3) & 0x07E0u) | (bits & ~0x07E0u));
+			}
+		}
+
+		/// <summary>
+		/// 5 bits
+		/// </summary>
+		public byte B
+		{
+			get => (byte)(((uint)bits << 3) & 0xF8);
+			set
+			{
+				bits = (ushort)((((uint)value >> 3) & 0x001Fu) | (bits & ~0x001Fu));
+			}
+		}
+
+		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)
+		{
+			bits = (ushort)(((r & 0xF8u) << 8) | ((g & 0xFCu) << 3) | ((b & 0xF8u) >> 3));
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGB24.cs

@@ -0,0 +1,24 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRGB24 : IColor<byte>
+	{
+		public byte R { get; set; }
+		public byte G { get; set; }
+		public byte B { get; set; }
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGB48.cs

@@ -0,0 +1,24 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRGB48 : IColor<ushort>
+	{
+		public ushort R { get; set; }
+		public ushort G { get; set; }
+		public ushort B { get; set; }
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGB9e5.cs

@@ -0,0 +1,90 @@
+using static System.Math;
+
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	/// <summary>
+	/// 9 bits each for RGB and 5 bits for an exponent
+	/// </summary>
+	public struct ColorRGB9e5 : IColor<float>
+	{
+		private uint bits;
+
+		public float R
+		{
+			get => (float)(RBits * Scale);
+			set
+			{
+				GetChannels(out _, out float g, out float b, out _);
+				SetChannels(value, g, b, default);
+			}
+		}
+
+		public float G
+		{
+			get => (float)(GBits * Scale);
+			set
+			{
+				GetChannels(out float r, out _, out float b, out _);
+				SetChannels(r, value, b, default);
+			}
+		}
+
+		public float B
+		{
+			get => (float)(BBits * Scale);
+			set
+			{
+				GetChannels(out float r, out float g, out _, out _);
+				SetChannels(r, g, value, default);
+			}
+		}
+
+		public float A
+		{
+			get => 1;
+			set { }
+		}
+
+		public void GetChannels(out float r, out float g, out float b, out float a)
+		{
+			double scale = Scale;
+			r = (float)(RBits * scale);
+			g = (float)(GBits * scale);
+			b = (float)(BBits * scale);
+			a = 1;
+		}
+
+		public void SetChannels(float r, float g, float b, float a)
+		{
+			int exponent = CalculateExponent(r, g, b);
+			double scale = Pow(2, exponent);
+			uint rBits = (uint)(r / scale) & 0x1FF;
+			uint gBits = (uint)(g / scale) & 0x1FF;
+			uint bBits = (uint)(b / scale) & 0x1FF;
+			uint exponentBits = unchecked((uint)(exponent + 24));
+			bits = (exponentBits << 27) | (bBits << 18) | (gBits << 9) | (rBits << 0);
+		}
+
+		/// <summary>
+		/// Range: -24 to 7 inclusive
+		/// </summary>
+		private int Exponent => unchecked((int)(bits >> 27) - 24);
+		private double Scale => Pow(2, Exponent);
+		private uint RBits => (bits >> 0) & 0x1FF;
+		private uint GBits => (bits >> 9) & 0x1FF;
+		private uint BBits => (bits >> 18) & 0x1FF;
+
+		private static int CalculateExponent(float r, float g, float b)
+		{
+			float maxChannel = Max(r, Max(g, b));
+			double minExponent = Log2(maxChannel / 0x1FF);
+			return (int)Ceiling(minExponent);
+		}
+
+#if NETSTANDARD
+		private static readonly double LogTwoConstant = Log(2);
+		[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+		private static double Log2(double value) => Log(value) / LogTwoConstant;
+#endif
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGBA16.cs

@@ -0,0 +1,39 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRGBA16 : IColor<byte>
+	{
+		private byte ba;
+		private byte rg;
+
+		public byte B
+		{
+			get => (byte)(ba & 0xF0u);
+			set => ba = (byte)((value & 0xF0u) | (ba & 0x0Fu));
+		}
+		public byte G
+		{
+			get => unchecked((byte)(rg << 4));
+			set => rg = unchecked((byte)(((uint)value >> 4) | (rg & 0xF0u)));
+		}
+		public byte R
+		{
+			get => (byte)(rg & 0xF0u);
+			set => rg = (byte)((value & 0xF0u) | (rg & 0x0Fu));
+		}
+		public byte A
+		{
+			get => unchecked((byte)(ba << 4));
+			set => ba = unchecked((byte)(((uint)value >> 4) | (ba & 0xF0u)));
+		}
+
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGBA32.cs

@@ -0,0 +1,20 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public 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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGBA64.cs

@@ -0,0 +1,20 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public 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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGBAHalf.cs

@@ -0,0 +1,20 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public 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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGBASingle.cs

@@ -0,0 +1,20 @@
+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);
+        }
+    }
+}

TextureDecoder/Rgb/Formats/ColorRGHalf.cs

@@ -0,0 +1,28 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRGHalf : IColor<Half>
+	{
+		public Half R { get; set; }
+		public Half G { get; set; }
+		public Half B
+		{
+			get => default;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRGSingle.cs

@@ -0,0 +1,28 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRGSingle : IColor<float>
+	{
+		public float R { get; set; }
+		public float G { get; set; }
+		public float B
+		{
+			get => default;
+			set { }
+		}
+		public float A
+		{
+			get => 1;
+			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/Rgb/Formats/ColorRHalf.cs

@@ -0,0 +1,32 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRHalf : IColor<Half>
+	{
+		public Half R { get; set; }
+		public Half G
+		{
+			get => default;
+			set { }
+		}
+		public Half B
+		{
+			get => default;
+			set { }
+		}
+		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);
+		}
+	}
+}

TextureDecoder/Rgb/Formats/ColorRSingle.cs

@@ -0,0 +1,32 @@
+namespace AssetRipper.TextureDecoder.Rgb.Formats
+{
+	public struct ColorRSingle : IColor<float>
+	{
+		public float R { get; set; }
+		public float G
+		{
+			get => default;
+			set { }
+		}
+		public float B
+		{
+			get => default;
+			set { }
+		}
+		public float A
+		{
+			get => 1;
+			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/Rgb/IColor.cs

@@ -0,0 +1,25 @@
+namespace AssetRipper.TextureDecoder.Rgb
+{
+	public interface IColor<T> where T : unmanaged
+	{
+		/// <summary>
+		/// The red channel
+		/// </summary>
+		T R { get; set; }
+		/// <summary>
+		/// The green channel
+		/// </summary>
+		T G { get; set; }
+		/// <summary>
+		/// The blue channel
+		/// </summary>
+		T B { get; set; }
+		/// <summary>
+		/// The alpha channel
+		/// </summary>
+		T A { get; set; }
+
+		void GetChannels(out T r, out T g, out T b, out T a);
+		void SetChannels(T r, T g, T b, T a);
+	}
+}

TextureDecoder/Rgb/RgbConverter.cs

@@ -1,5 +1,6 @@
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace AssetRipper.TextureDecoder.Rgb
 {
@@ -398,7 +399,7 @@ namespace AssetRipper.TextureDecoder.Rgb
 			output = new byte[width * height * 4];
 			return RGBAFloatToBGRA32(input, width, height, output);
 		}
-		
+
 		public static int RGBAFloatToBGRA32(ReadOnlySpan<byte> input, int width, int height, Span<byte> output)
 		{
 			int io = 0;
@@ -527,6 +528,48 @@ namespace AssetRipper.TextureDecoder.Rgb
 			return io;
 		}
 
+		public static int Convert<TSource, TSourceArg, TDestination, TDestinationArg>(ReadOnlySpan<byte> input, int width, int height, out byte[] output)
+			where TSourceArg : unmanaged
+			where TSource : unmanaged, IColor<TSourceArg>
+			where TDestinationArg : unmanaged
+			where TDestination : unmanaged, IColor<TDestinationArg>
+		{
+			output = new byte[width * height * Unsafe.SizeOf<TDestination>()];
+			return Convert<TSource, TSourceArg, TDestination, TDestinationArg>(input, width, height, output);
+		}
+
+		public static int Convert<TSource, TSourceArg, TDestination, TDestinationArg>(ReadOnlySpan<byte> input, int width, int height, Span<byte> output)
+			where TSourceArg : unmanaged
+			where TSource : unmanaged, IColor<TSourceArg>
+			where TDestinationArg : unmanaged
+			where TDestination : unmanaged, IColor<TDestinationArg>
+		{
+			ReadOnlySpan<TSource> sourceSpan = MemoryMarshal.Cast<byte, TSource>(input).Slice(0, width * height);
+			Span<TDestination> destinationSpan = MemoryMarshal.Cast<byte, TDestination>(output).Slice(0, width * height);
+			Convert<TSource, TSourceArg, TDestination, TDestinationArg>(sourceSpan, destinationSpan);
+			return width * height * Unsafe.SizeOf<TSource>();
+		}
+
+		public static void Convert<TSource, TSourceArg, TDestination, TDestinationArg>(ReadOnlySpan<TSource> sourceSpan, Span<TDestination> destinationSpan)
+			where TSourceArg : unmanaged
+			where TSource : unmanaged, IColor<TSourceArg>
+			where TDestinationArg : unmanaged
+			where TDestination : unmanaged, IColor<TDestinationArg>
+		{
+			for (int i = 0; i < sourceSpan.Length; i++)
+			{
+				TSource source = sourceSpan[i];
+				TDestination destination = default;
+				source.GetChannels(out TSourceArg r, out TSourceArg g, out TSourceArg b, out TSourceArg a);
+				destination.SetChannels(
+					ConversionUtilities.ConvertValue<TSourceArg, TDestinationArg>(r),
+					ConversionUtilities.ConvertValue<TSourceArg, TDestinationArg>(g),
+					ConversionUtilities.ConvertValue<TSourceArg, TDestinationArg>(b),
+					ConversionUtilities.ConvertValue<TSourceArg, TDestinationArg>(a));
+				destinationSpan[i] = destination;
+			}
+		}
+
 		private static float ToHalf(ReadOnlySpan<byte> input, int offset)
 		{
 #if NET6_0_OR_GREATER