From 2f000fb0b5d3f7d13818c770550eaae02b7af185 Mon Sep 17 00:00:00 2001 From: popow Date: Sat, 2 Jun 2018 16:26:26 +0200 Subject: [PATCH] refactored remaining packed pixel tests --- .../PixelFormats/PackedPixelTests.cs | 3406 ++++++++++++----- 1 file changed, 2382 insertions(+), 1024 deletions(-) diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs index 06b6aaa61..cd0435c4a 100644 --- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs +++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs @@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Tests.Colors public class PackedPixelTests { [Fact] - public void Alpha8() + public void Alpha8_PackedValue() { // Test the limits. Assert.Equal(0x0, new Alpha8(0F).PackedValue); @@ -31,1326 +31,2688 @@ namespace SixLabors.ImageSharp.Tests.Colors // Test ordering Assert.Equal(124, new Alpha8(124F / 0xFF).PackedValue); Assert.Equal(26, new Alpha8(0.1F).PackedValue); + } + + [Fact] + public void Alpha8_ToVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + var actual = alpha.ToVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } + + [Fact] + public void Alpha8_ToScaledVector4() + { + // arrange + var alpha = new Alpha8(.5F); + + // act + Vector4 actual = alpha.ToScaledVector4(); - // Test ToVector4. - var vector = new Alpha8(.5F).ToVector4(); - Assert.Equal(0, vector.X); - Assert.Equal(0, vector.Y); - Assert.Equal(0, vector.Z); - Assert.Equal(.5F, vector.W, 2); + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(.5F, actual.W, 2); + } - // Test ToScaledVector4. + [Fact] + public void Alpha8_PackFromScaledVector4() + { + // arrange + Alpha8 alpha = default; + int expected = 128; Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(.5F, scaled.W, 2); - // Test PackFromScaledVector4. + // act + alpha.PackFromScaledVector4(scaled); + byte actual = alpha.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgb24() + { + // arrange + Rgb24 actual = default; Alpha8 alpha = default; + var expected = new Rgb24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act alpha.PackFromScaledVector4(scaled); - Assert.Equal(128, alpha.PackedValue); + alpha.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } - // Test Rgb conversion - Rgb24 rgb = default; - Rgba32 rgba = default; - Bgr24 bgr = default; - Bgra32 bgra = default; - Argb32 argb = default; + [Fact] + public void Alpha8_PackFromScaledVector4_ToRgba32() + { + // arrange + Rgba32 actual = default; + Alpha8 alpha = default; + var expected = new Rgba32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - alpha.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0, 0, 0)); + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToRgba32(ref actual); - alpha.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0, 0, 0, 128)); + // assert + Assert.Equal(expected, actual); + } - alpha.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0, 0, 0)); + [Fact] + public void Alpha8_PackFromScaledVector4_ToBgr24() + { + // arrange + Bgr24 actual = default; + Alpha8 alpha = default; + var expected = new Bgr24(0, 0, 0); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); - alpha.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0, 0, 0, 128)); + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgr24(ref actual); - alpha.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0, 0, 0, 128)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Argb32() + public void Alpha8_PackFromScaledVector4_ToBgra32() { - // Test the limits. + // arrange + Bgra32 actual = default; + Alpha8 alpha = default; + var expected = new Bgra32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Alpha8_PackFromScaledVector4_ToArgb32() + { + // arrange + Alpha8 alpha = default; + Argb32 actual = default; + var expected = new Argb32(0, 0, 0, 128); + Vector4 scaled = new Alpha8(.5F).ToScaledVector4(); + + // act + alpha.PackFromScaledVector4(scaled); + alpha.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Argb32_PackedValue() + { + Assert.Equal(0x80001a00u, new Argb32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); Assert.Equal((uint)0x0, new Argb32(Vector4.Zero).PackedValue); Assert.Equal(0xFFFFFFFF, new Argb32(Vector4.One).PackedValue); + } - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Argb32(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4())); + [Fact] + public void Argb32_ToVector4() + { + Assert.Equal(Vector4.One, new Argb32(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Argb32(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Argb32(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Argb32(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Argb32(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Argb32(Vector4.UnitW).ToVector4()); + } - // Test ToScaledVector4. - Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + [Fact] + public void Argb32_ToScaledVector4() + { + // arrange + var argb = new Argb32(Vector4.One); + + // act + Vector4 actual = argb.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - // Test PackFromScaledVector4. + [Fact] + public void Argb32_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4(); var pixel = default(Argb32); + uint expected = 0xFFFFFFFF; + + // act pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); + uint actual = pixel.PackedValue; - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4())); + // assert + Assert.Equal(expected, actual); + } - float x = +0.1f; - float y = -0.3f; - float z = +0.5f; - float w = -0.7f; - var argb = new Argb32(x, y, z, w); - Assert.Equal(0x80001a00u, argb.PackedValue); + [Fact] + public void Argb32_Clamping() + { + Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4()); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb2 = default(Argb32); + [Fact] + public void Argb32_ToRgb24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); - argb.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80)); + // act + argb.ToRgb24(ref actual); - argb.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); - Assert.Equal(rgba, argb.ToRgba32()); + // assert + Assert.Equal(expected, actual); + } - argb.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80)); + [Fact] + public void Argb32_ToRgba32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); - argb.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, argb.ToBgra32()); + // act + argb.ToRgba32(ref actual); - argb.ToArgb32(ref argb2); - Assert.Equal(argb2, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb2, argb.ToArgb32()); + // assert + Assert.Equal(expected, actual); + } - var r = default(Argb32); - r.PackFromRgba32(new Rgba32(0x1a, 0, 0x80, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); + [Fact] + public void Argb32_ToBgr24() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); - r = default(Argb32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); + // act + argb.ToBgr24(ref actual); - r = default(Argb32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgr565() + public void Argb32_ToBgra32() { - // Test the limits. - Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); - - // Test ToVector3. - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3())); - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3())); - Assert.True(Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3())); - Assert.True(Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3())); - Assert.True(Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3())); + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); - // Test ToScaledVector4. - Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // act + argb.ToBgra32(ref actual); - // Test PackFromScaledVector4. - var pixel = default(Bgr565); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test clamping. - Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3())); - Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3())); + [Fact] + public void Argb32_ToArgb32() + { + // arrange + var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // Make sure the swizzle is correct. - Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); - Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); - Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); + // act + argb.ToArgb32(ref actual); - float x = 0.1F; - float y = -0.3F; - float z = 0.5F; - Assert.Equal(6160, new Bgr565(x, y, z).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); + [Fact] + public void Argb32_PackFromRgba32_ToRgba32() + { + // arrange var argb = default(Argb32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); - new Bgr565(x, y, z).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 132)); + // act + argb.PackFromRgba32(expected); + argb.ToRgba32(ref actual); - new Bgr565(x, y, z).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 132, 255)); + // assert + Assert.Equal(expected, actual); + } - new Bgr565(x, y, z).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 132)); + [Fact] + public void Argb32_PackFromBgra32_ToBgra32() + { + // arrange + var argb = default(Argb32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); - new Bgr565(x, y, z).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 132, 255)); + // act + argb.PackFromBgra32(expected); + argb.ToBgra32(ref actual); - new Bgr565(x, y, z).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 132, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgra4444() + public void Argb32_PackFromArgb32_ToArgb32() { - // Test the limits. - Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); - - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var argb = default(Argb32); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // Test PackFromScaledVector4. - var pixel = default(Bgra4444); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + // act + argb.PackFromArgb32(expected); + argb.ToArgb32(ref actual); - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4())); + // assert + Assert.Equal(expected, actual); + } + [Fact] + public void Bgr565_PackedValue() + { + Assert.Equal(6160, new Bgr565(0.1F, -0.3F, 0.5F).PackedValue); + Assert.Equal(0x0, new Bgr565(Vector3.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgr565(Vector3.One).PackedValue); // Make sure the swizzle is correct. - Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); - Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); - Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); - Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); + Assert.Equal(0xF800, new Bgr565(Vector3.UnitX).PackedValue); + Assert.Equal(0x07E0, new Bgr565(Vector3.UnitY).PackedValue); + Assert.Equal(0x001F, new Bgr565(Vector3.UnitZ).PackedValue); + } + + [Fact] + public void Bgr565_ToVector3() + { + Assert.True(Equal(Vector3.One, new Bgr565(Vector3.One).ToVector3())); + Assert.True(Equal(Vector3.Zero, new Bgr565(Vector3.Zero).ToVector3())); + Assert.True(Equal(Vector3.UnitX, new Bgr565(Vector3.UnitX).ToVector3())); + Assert.True(Equal(Vector3.UnitY, new Bgr565(Vector3.UnitY).ToVector3())); + Assert.True(Equal(Vector3.UnitZ, new Bgr565(Vector3.UnitZ).ToVector3())); + } - float x = 0.1f; - float y = -0.3f; - float z = 0.5f; - float w = -0.7f; - Assert.Equal(520, new Bgra4444(x, y, z, w).PackedValue); + [Fact] + public void Bgr565_ToScaledVector4() + { + // arrange + var bgr = new Bgr565(Vector3.One); - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + // act + Vector4 actual = bgr.ToScaledVector4(); - new Bgra4444(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(34, 0, 136)); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - new Bgra4444(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(34, 0, 136, 0)); + [Fact] + public void Bgr565_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgr565); - new Bgra4444(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(34, 0, 136)); + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; - new Bgra4444(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); + // assert + Assert.Equal(expected, actual); + } - new Bgra4444(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); + [Fact] + public void Bgr565_Clamping() + { + Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3()); + Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3()); + } - var r = default(Bgra4444); - r.PackFromRgba32(new Rgba32(34, 0, 136, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(34, 0, 136, 0)); + [Fact] + public void Bgr565_ToRgb24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 132); - r = default(Bgra4444); - r.PackFromBgra32(new Bgra32(34, 0, 136, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(34, 0, 136, 0)); + // act + bgra.ToRgb24(ref actual); - r = default(Bgra4444); - r.PackFromArgb32(new Argb32(34, 0, 136, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(34, 0, 136, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Bgra5551() + public void Bgr565_ToRgba32() { - // Test the limits. - Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 132, 255); - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4())); + // act + bgra.ToRgba32(ref actual); - // Test ToScaledVector4. - Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // assert + Assert.Equal(expected, actual); + } - // Test PackFromScaledVector4. - var pixel = default(Bgra5551); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFF, pixel.PackedValue); + [Fact] + public void Bgr565_ToBgr24() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 132); - // Test clamping. - Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); - Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); + // act + bgra.ToBgr24(ref actual); - // Test Ordering - float x = 0x1a; - float y = 0x16; - float z = 0xd; - float w = 0x1; - Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); - x = 0.1f; - y = -0.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal(3088, new Bgra5551(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void Bgr565_ToBgra32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 132, 255); - new Bgra5551(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(24, 0, 131)); + // act + bgra.ToBgra32(ref actual); - new Bgra5551(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgr565_ToArgb32() + { + // arrange + var bgra = new Bgr565(0.1F, -0.3F, 0.5F); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 132, 255); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackedValue() + { + Assert.Equal(520, new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal(0x0, new Bgra4444(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra4444(Vector4.One).PackedValue); + Assert.Equal(0x0F00, new Bgra4444(Vector4.UnitX).PackedValue); + Assert.Equal(0x00F0, new Bgra4444(Vector4.UnitY).PackedValue); + Assert.Equal(0x000F, new Bgra4444(Vector4.UnitZ).PackedValue); + Assert.Equal(0xF000, new Bgra4444(Vector4.UnitW).PackedValue); + } + + [Fact] + public void Bgra4444_ToVector4() + { + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX, new Bgra4444(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new Bgra4444(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new Bgra4444(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new Bgra4444(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void Bgra4444_ToScaledVector4() + { + // arrange + var bgra = new Bgra4444(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra4444_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var bgra = default(Bgra4444); + + // act + bgra.PackFromScaledVector4(scaled); + ushort actual = bgra.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra4444_ToRgb24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(34, 0, 136); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToRgba32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgr24() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(34, 0, 136); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToBgra32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_ToArgb32() + { + // arrange + var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Rgba32); + var expected = new Rgba32(34, 0, 136, 0); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Bgra32); + var expected = new Bgra32(34, 0, 136, 0); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra4444_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra4444); + var actual = default(Argb32); + var expected = new Argb32(34, 0, 136, 0); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackedValue() + { + float x = 0x1a; + float y = 0x16; + float z = 0xd; + float w = 0x1; + Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue); + Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal(0x0, new Bgra5551(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFF, new Bgra5551(Vector4.One).PackedValue); + } + + [Fact] + public void Bgra5551_ToVector4() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One).ToVector4()); + } + + [Fact] + public void Bgra5551_ToScaledVector4() + { + // arrange + var bgra = new Bgra5551(Vector4.One); + + // act + Vector4 actual = bgra.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Bgra5551_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4(); + int expected = 0xFFFF; + var pixel = default(Bgra5551); + pixel.PackFromScaledVector4(scaled); + + // act + pixel.PackFromScaledVector4(scaled); + ushort actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Clamping() + { + Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); + } + + [Fact] + public void Bgra5551_ToRgb24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(24, 0, 131); + + // act + bgra.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Rgba32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(24, 0, 131, 0); + + // act + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToBgr24() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(24, 0, 131); + + // act + bgra.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_Bgra32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(24, 0, 131, 0); + + // act + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_ToArgb32() + { + // arrange + var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(24, 0, 131, 0); + + // act + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromRgba32_ToRgba32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Rgba32(24, 0, 131, 0); + var actual = default(Rgba32); + + // act + bgra.PackFromRgba32(expected); + bgra.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromBgra32_ToBgra32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Bgra32(24, 0, 131, 0); + var actual = default(Bgra32); + + // act + bgra.PackFromBgra32(expected); + bgra.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Bgra5551_PackFromArgb32_ToArgb32() + { + // arrange + var bgra = default(Bgra5551); + var expected = new Argb32(24, 0, 131, 0); + var actual = default(Argb32); + + // act + bgra.PackFromArgb32(expected); + bgra.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackedValue() + { + Assert.Equal((uint)128, new Byte4(127.5f, -12.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)0x1a7b362d, new Byte4(0x2d, 0x36, 0x7b, 0x1a).PackedValue); + Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); + } + + [Fact] + public void Byte4_ToVector4() + { + Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4()); + Assert.Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4()); + Assert.Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4()); + Assert.Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4()); + Assert.Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4()); + } + + [Fact] + public void Byte4_ToScaledVector4() + { + // arrange + var byte4 = new Byte4(Vector4.One * 255); + + // act + Vector4 actual = byte4.ToScaledVector4(); + + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void Byte4_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); + var pixel = default(Byte4); + uint expected = 0xFFFFFFFF; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4())); + } + + [Fact] + public void Byte4_ToRgb24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + byte4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Rgba32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 0); + + // act + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_ToBgr24() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + byte4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Bgra32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 0); + + // act + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_Argb32() + { + // arrange + var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 0); + + // act + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromRgba32_ToRgba32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); + + // act + byte4.PackFromRgba32(expected); + byte4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromBgra32_ToBgra32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); + + // act + byte4.PackFromBgra32(expected); + byte4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void Byte4_PackFromArgb32_ToArgb32() + { + // arrange + var byte4 = default(Byte4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); + + // act + byte4.PackFromArgb32(expected); + byte4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_PackedValue() + { + Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); + Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); + + // Test limits + Assert.Equal(15360, new HalfSingle(1F).PackedValue); + Assert.Equal(0, new HalfSingle(0F).PackedValue); + Assert.Equal(48128, new HalfSingle(-1F).PackedValue); + } + + [Fact] + public void HalfSingle_ToVector4() + { + // arrange + var halfSingle = new HalfSingle(0.5f); + var expected = new Vector4(0.5f, 0, 0, 1); + + // act + var actual = halfSingle.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToScaledVector4() + { + // arrange + var halfSingle = new HalfSingle(-1F); + + // act + Vector4 actual = halfSingle.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfSingle_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); + int expected = 48128; + var halfSingle = default(HalfSingle); + + // act + halfSingle.PackFromScaledVector4(scaled); + ushort actual = halfSingle.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToRgb24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 0, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Rgba32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 0, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_ToBgr24() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 0, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Bgra32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 0, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfSingle_Argb32() + { + // arrange + var halfVector = new HalfSingle(.5F); + var actual = default(Argb32); + var expected = new Argb32(128, 0, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_PackedValue() + { + Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); + Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); + Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); + } + + [Fact] + public void HalfVector2_ToVector2() + { + Assert.True(Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2())); + Assert.True(Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2())); + Assert.True(Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2())); + } + + [Fact] + public void HalfVector2_ToScaledVector4() + { + // arrange + var halfVector = new HalfVector2(Vector2.One); + + // act + Vector4 actual = halfVector.ToScaledVector4(); + + // assert + Assert.Equal(1F, actual.X); + Assert.Equal(1F, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } + + [Fact] + public void HalfVector2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); + uint expected = 1006648320u; + var halfVector = default(HalfVector2); + + // act + halfVector.PackFromScaledVector4(scaled); + uint actual = halfVector.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToVector4() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var expected = new Vector4(0.5f, .25F, 0, 1); + + // act + var actual = halfVector.ToVector4(); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToRgb24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgb24); + var expected = new Rgb24(128, 64, 0); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Rgba32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Rgba32); + var expected = new Rgba32(128, 64, 0, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_ToBgr24() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgr24); + var expected = new Bgr24(128, 64, 0); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Bgra32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Bgra32); + var expected = new Bgra32(128, 64, 0, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector2_Argb32() + { + // arrange + var halfVector = new HalfVector2(.5F, .25F); + var actual = default(Argb32); + var expected = new Argb32(128, 64, 0, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackedValue() + { + Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); + Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); + Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); + Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); + Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); + Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); + Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); + Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); + } + + [Fact] + public void HalfVector4_ToVector4() + { + Assert.Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4()); + Assert.Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4()); + Assert.Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4()); + Assert.Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4()); + Assert.Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4()); + } + + [Fact] + public void HalfVector4_ToScaledVector4() + { + // arrange + var halfVector4 = new HalfVector4(-Vector4.One); + + // act + Vector4 actual = halfVector4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void HalfVector4_PackFromScaledVector4() + { + // arrange + var halfVector4 = default(HalfVector4); + Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); + ulong expected = 13547034390470638592uL; + + // act + halfVector4.PackFromScaledVector4(scaled); + ulong actual = halfVector4.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToRgb24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgb24); + var expected = new Rgb24(64, 128, 191); + + // act + halfVector.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Rgba32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halfVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_ToBgr24() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgr24); + var expected = new Bgr24(64, 128, 191); + + // act + halfVector.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Bgra32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halfVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_Argb32() + { + // arrange + var halfVector = new HalfVector4(.25F, .5F, .75F, 1F); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halfVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromRgba32_ToRgba32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Rgba32); + var expected = new Rgba32(64, 128, 191, 255); + + // act + halVector.PackFromRgba32(expected); + halVector.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromBgra32_ToBgra32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Bgra32); + var expected = new Bgra32(64, 128, 191, 255); + + // act + halVector.PackFromBgra32(expected); + halVector.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void HalfVector4_PackFromArgb32_ToArgb32() + { + // arrange + var halVector = default(HalfVector4); + var actual = default(Argb32); + var expected = new Argb32(64, 128, 191, 255); + + // act + halVector.PackFromArgb32(expected); + halVector.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_PackedValue() + { + Assert.Equal(0xda0d, new NormalizedByte2(0.1f, -0.3f).PackedValue); + Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); + Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); + Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); + } + + [Fact] + public void NormalizedByte2_ToVector2() + { + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2()); + Assert.Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2()); + Assert.Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2()); + Assert.Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2()); + } + + [Fact] + public void NormalizedByte2_ToVector4() + { + Assert.Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4()); + Assert.Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4()); + } + + [Fact] + public void NormalizedByte2_ToScaledVector4() + { + // arrange + var byte2 = new NormalizedByte2(-Vector2.One); + + // act + Vector4 actual = byte2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1F, actual.W); + } + + [Fact] + public void NormalizedByte2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); + var byte2 = default(NormalizedByte2); + uint expected = 0x8181; + + // act + byte2.PackFromScaledVector4(scaled); + uint actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_PackFromRgba32() + { + // arrange + var byte2 = new NormalizedByte2(); + var rgba = new Rgba32(141, 90, 0, 0); + int expected = 0xda0d; + + // act + byte2.PackFromRgba32(rgba); + ushort actual = byte2.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgb24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToRgba32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgr24() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToBgra32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); + + // act + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte2_ToArgb32() + { + // arrange + var short4 = new NormalizedByte2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackedValues() + { + Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); + Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); + Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + } + + [Fact] + public void NormalizedByte4_ToVector4() + { + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4()); + Assert.Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4()); + Assert.Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4()); + Assert.Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4()); + } + + [Fact] + public void NormalizedByte4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedByte4(-Vector4.One); + + // act + Vector4 actual = short4.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(0, actual.W); + } + + [Fact] + public void NormalizedByte4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedByte4); + Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + uint expected = 0x81818181; + + // act + pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgb24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); + + // act + short4.ToRgb24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToRgba32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); + + // act + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToBgr24() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); + + // act + short4.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_ToArgb32() + { + // arrange + var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); + + // act + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromRgba32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Rgba32); + var expected = new Rgba32(9, 115, 202, 127); + + // act + short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); + short4.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromBgra32_ToRgba32() + { + // arrange + var actual = default(Bgra32); + var short4 = default(NormalizedByte4); + var expected = new Bgra32(9, 115, 202, 127); + + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedByte4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedByte4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); + + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); + + // assert + Assert.Equal(expected, actual); + } + + [Fact] + public void NormalizedShort2_PackedValue() + { + Assert.Equal(0xE6672CCC, new NormalizedShort2(0.35f, -0.2f).PackedValue); + Assert.Equal(3650751693, new NormalizedShort2(0.1f, -0.3f).PackedValue); + Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); + Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); + Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); + // TODO: I don't think this can ever pass since the bytes are already truncated. + // Assert.Equal(3650751693, n.PackedValue); + } + + [Fact] + public void NormalizedShort2_ToVector2() + { + Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2())); + Assert.True(Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2())); + Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2())); + Assert.True(Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2())); + } + + [Fact] + public void NormalizedShort2_ToVector4() + { + Assert.True(Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4())); + Assert.True(Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4())); + } + + [Fact] + public void NormalizedShort2_ToScaledVector4() + { + // arrange + var short2 = new NormalizedShort2(-Vector2.One); + + // act + Vector4 actual = short2.ToScaledVector4(); + + // assert + Assert.Equal(0, actual.X); + Assert.Equal(0, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } - new Bgra5551(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(24, 0, 131)); + [Fact] + public void NormalizedShort2_PackFromScaledVector4() + { + // arrange + Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); + var short2 = default(NormalizedShort2); + uint expected = 0x80018001; - new Bgra5551(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); + // act + short2.PackFromScaledVector4(scaled); + uint actual = short2.PackedValue; - new Bgra5551(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); + } - var r = default(Bgra5551); - r.PackFromRgba32(new Rgba32(24, 0, 131, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(24, 0, 131, 0)); + [Fact] + public void NormalizedShort2_PackFromRgba32_ToRgb24() + { + // arrange + var actual = default(Rgb24); + var short2 = new NormalizedShort2(); + var rgba = new Rgba32(141, 90, 0, 0); + var expected = new Rgb24(141, 90, 0); - r = default(Bgra5551); - r.PackFromBgra32(new Bgra32(24, 0, 131, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(24, 0, 131, 0)); + // act + short2.PackFromRgba32(rgba); + short2.ToRgb24(ref actual); - r = default(Bgra5551); - r.PackFromArgb32(new Argb32(24, 0, 131, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(24, 0, 131, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Byte4() + public void NormalizedShort2_ToRgb24() { - // Test the limits. - Assert.Equal((uint)0x0, new Byte4(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Byte4(Vector4.One * 255).PackedValue); + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 0); - // Test ToVector4. - Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 255).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX * 255, new Byte4(Vector4.UnitX * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitY * 255, new Byte4(Vector4.UnitY * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitZ * 255, new Byte4(Vector4.UnitZ * 255).ToVector4())); - Assert.True(Equal(Vector4.UnitW * 255, new Byte4(Vector4.UnitW * 255).ToVector4())); + // act + short2.ToRgb24(ref actual); - // Test ToScaledVector4. - Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // assert + Assert.Equal(expected, actual); + } - // Test PackFromScaledVector4. - var pixel = default(Byte4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); + [Fact] + public void NormalizedShort2_ToRgba32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 0, 255); - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4())); + // act + short2.ToRgba32(ref actual); - // Test ordering - float x = 0x2d; - float y = 0x36; - float z = 0x7b; - float w = 0x1a; - Assert.Equal((uint)0x1a7b362d, new Byte4(x, y, z, w).PackedValue); - - x = 127.5f; - y = -12.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal((uint)128, new Byte4(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort2_ToBgr24() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 0); - new Byte4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); + // act + short2.ToBgr24(ref actual); - new Byte4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 0)); + // assert + Assert.Equal(expected, actual); + } - new Byte4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); + [Fact] + public void NormalizedShort2_ToBgra32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Bgra32); + var expected = new Bgra32(141, 90, 0, 255); - new Byte4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 0)); + // act + short2.ToBgra32(ref actual); - new Byte4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 0)); + // assert + Assert.Equal(expected, actual); + } - var r = default(Byte4); - r.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 0, 255)); + [Fact] + public void NormalizedShort2_ToArgb32() + { + // arrange + var short2 = new NormalizedShort2(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 0, 255); - r = default(Byte4); - r.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 0, 255)); + // act + short2.ToArgb32(ref actual); - r = default(Byte4); - r.PackFromArgb32(new Argb32(20, 38, 0, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(20, 38, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfSingle() + public void NormalizedShort4_PackedValues() { - // Test limits - Assert.Equal(15360, new HalfSingle(1F).PackedValue); - Assert.Equal(0, new HalfSingle(0F).PackedValue); - Assert.Equal(48128, new HalfSingle(-1F).PackedValue); + Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); + Assert.Equal((ulong)0x0, new NormalizedShort4(Vector4.Zero).PackedValue); + Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new NormalizedShort4(Vector4.One).PackedValue); + Assert.Equal(0x8001800180018001, new NormalizedShort4(-Vector4.One).PackedValue); + } - // Test values - Assert.Equal(11878, new HalfSingle(0.1F).PackedValue); - Assert.Equal(46285, new HalfSingle(-0.3F).PackedValue); + [Fact] + public void NormalizedShort4_ToVector4() + { + // Test ToVector4 + Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.Zero, new NormalizedShort4(Vector4.Zero).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedShort4(-Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One * 1234.0f).ToVector4())); + Assert.True(Equal(-Vector4.One, new NormalizedShort4(Vector4.One * -1234.0f).ToVector4())); + } - // Test ordering - float x = .5F; - Assert.True(Equal(new Vector4(x, 0, 0, 1), new HalfSingle(x).ToVector4())); + [Fact] + public void NormalizedShort4_ToScaledVector4() + { + // arrange + var short4 = new NormalizedShort4(Vector4.One); - // Test ToScaledVector4. - Vector4 scaled = new HalfSingle(-1F).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + // act + Vector4 actual = short4.ToScaledVector4(); - // Test PackFromScaledVector4. - var pixel = default(HalfSingle); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(48128, pixel.PackedValue); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_PackFromScaledVector4() + { + // arrange + var pixel = default(NormalizedShort4); + Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + ulong expected = (ulong)0x7FFF7FFF7FFF7FFF; - new HalfSingle(x).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 0, 0)); + // act + pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; - new HalfSingle(x).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfSingle(x).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 0, 0)); + [Fact] + public void NormalizedShort4_ToRgb24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(141, 90, 192); - new HalfSingle(x).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 0, 0, 255)); + // act + short4.ToRgb24(ref actual); - new HalfSingle(x).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfVector2() + public void NormalizedShort4_ToRgba32() { - // Test PackedValue - Assert.Equal(0u, new HalfVector2(Vector2.Zero).PackedValue); - Assert.Equal(1006648320u, new HalfVector2(Vector2.One).PackedValue); - Assert.Equal(3033345638u, new HalfVector2(0.1f, -0.3f).PackedValue); - - // Test ToVector2 - Assert.True(Equal(Vector2.Zero, new HalfVector2(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One, new HalfVector2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.UnitX, new HalfVector2(Vector2.UnitX).ToVector2())); - Assert.True(Equal(Vector2.UnitY, new HalfVector2(Vector2.UnitY).ToVector2())); - - // Test ToScaledVector4. - Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4(); - Assert.Equal(1F, scaled.X); - Assert.Equal(1F, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(141, 90, 192, 39); - // Test PackFromScaledVector4. - var pixel = default(HalfVector2); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(1006648320u, pixel.PackedValue); + // act + short4.ToRgba32(ref actual); - // Test ordering - float x = .5F; - float y = .25F; - Assert.True(Equal(new Vector4(x, y, 0, 1), new HalfVector2(x, y).ToVector4())); + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_ToBgr24() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(141, 90, 192); - new HalfVector2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(128, 64, 0)); + // act + short4.ToBgr24(ref actual); - new HalfVector2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(128, 64, 0, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfVector2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(128, 64, 0)); + [Fact] + public void NormalizedShort4_ToArgb32() + { + // arrange + var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(141, 90, 192, 39); - new HalfVector2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(128, 64, 0, 255)); + // act + short4.ToArgb32(ref actual); - new HalfVector2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(128, 64, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void HalfVector4() + public void NormalizedShort4_PackFromRgba32_ToRgba32() { - // Test PackedValue - Assert.Equal(0uL, new HalfVector4(Vector4.Zero).PackedValue); - Assert.Equal(4323521613979991040uL, new HalfVector4(Vector4.One).PackedValue); - Assert.Equal(13547034390470638592uL, new HalfVector4(-Vector4.One).PackedValue); - Assert.Equal(15360uL, new HalfVector4(Vector4.UnitX).PackedValue); - Assert.Equal(1006632960uL, new HalfVector4(Vector4.UnitY).PackedValue); - Assert.Equal(65970697666560uL, new HalfVector4(Vector4.UnitZ).PackedValue); - Assert.Equal(4323455642275676160uL, new HalfVector4(Vector4.UnitW).PackedValue); - Assert.Equal(4035285078724390502uL, new HalfVector4(0.1f, 0.3f, 0.4f, 0.5f).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new HalfVector4(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new HalfVector4(Vector4.One).ToVector4())); - Assert.True(Equal(-Vector4.One, new HalfVector4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new HalfVector4(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new HalfVector4(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new HalfVector4(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new HalfVector4(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(0, scaled.W); + // arrange + var short4 = default(NormalizedShort4); + var expected = new Rgba32(9, 115, 202, 127); + var actual = default(Rgba32); - // Test PackFromScaledVector4. - var pixel = default(HalfVector4); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(13547034390470638592uL, pixel.PackedValue); + // act + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); - // Test ordering - float x = .25F; - float y = .5F; - float z = .75F; - float w = 1F; + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + [Fact] + public void NormalizedShort4_PackFromBgra32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Bgra32); + var expected = new Bgra32(9, 115, 202, 127); - new HalfVector4(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(64, 128, 191)); + // act + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); - new HalfVector4(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(64, 128, 191, 255)); + // assert + Assert.Equal(expected, actual); + } - new HalfVector4(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(64, 128, 191)); + [Fact] + public void NormalizedShort4_PackFromArgb32_ToRgba32() + { + // arrange + var short4 = default(NormalizedShort4); + var actual = default(Argb32); + var expected = new Argb32(9, 115, 202, 127); - new HalfVector4(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); + // act + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); - new HalfVector4(x, y, z, w).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(64, 128, 191, 255)); + // assert + Assert.Equal(expected, actual); + } - var r = default(HalfVector4); - r.PackFromRgba32(new Rgba32(64, 128, 191, 255)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(64, 128, 191, 255)); + [Fact] + public void Rg32_PackedValues() + { + float x = 0xb6dc; + float y = 0xA59f; + Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); + Assert.Equal((uint)6554, new Rg32(0.1f, -0.3f).PackedValue); - r = default(HalfVector4); - r.PackFromBgra32(new Bgra32(64, 128, 191, 255)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(64, 128, 191, 255)); + // Test the limits. + Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); + } - r = default(HalfVector4); - r.PackFromArgb32(new Argb32(64, 128, 191, 255)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(64, 128, 191, 255)); + [Fact] + public void Rg32_ToVector2() + { + Assert.Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2()); + Assert.Equal(Vector2.One, new Rg32(Vector2.One).ToVector2()); } [Fact] - public void NormalizedByte2() + public void Rg32_ToScaledVector4() { - // Test PackedValue - Assert.Equal(0x0, new NormalizedByte2(Vector2.Zero).PackedValue); - Assert.Equal(0x7F7F, new NormalizedByte2(Vector2.One).PackedValue); - Assert.Equal(0x8181, new NormalizedByte2(-Vector2.One).PackedValue); + // arrange + var rg32 = new Rg32(Vector2.One); - // Test ToVector2 - Assert.True(Equal(Vector2.One, new NormalizedByte2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.Zero, new NormalizedByte2(Vector2.Zero).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedByte2(-Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.One, new NormalizedByte2(Vector2.One * 1234.0f).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedByte2(Vector2.One * -1234.0f).ToVector2())); + // act + Vector4 actual = rg32.ToScaledVector4(); - // Test ToVector4 - Assert.True(Equal(new Vector4(1, 1, 0, 1), new NormalizedByte2(Vector2.One).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), new NormalizedByte2(Vector2.Zero).ToVector4())); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); + } - // Test ToScaledVector4. - Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1F, scaled.W); + [Fact] + public void Rg32_PackFromScaledVector4() + { + // arrange + var rg32 = new Rg32(Vector2.One); + var pixel = default(Rg32); + uint expected = 0xFFFFFFFF; - // Test PackFromScaledVector4. - var pixel = default(NormalizedByte2); + // act + Vector4 scaled = rg32.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); - Assert.Equal(0x8181, pixel.PackedValue); - - // Test Ordering - float x = 0.1f; - float y = -0.3f; - Assert.Equal(0xda0d, new NormalizedByte2(x, y).PackedValue); - var n = new NormalizedByte2(); - n.PackFromRgba32(new Rgba32(141, 90, 0, 0)); - Assert.Equal(0xda0d, n.PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); + uint actual = pixel.PackedValue; - new NormalizedByte2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); + // assert + Assert.Equal(expected, actual); + } - new NormalizedByte2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 0, 255)); + [Fact] + public void Rg32_Clamping() + { + Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2())); + Assert.True(Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2())); + } - new NormalizedByte2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 0)); + [Fact] + public void Rg32_ToRgb24() + { + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 0); - new NormalizedByte2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); + // act + rg32.ToRgb24(ref actual); - new NormalizedByte2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackedValues() + public void Rg32_ToRgba32() { - Assert.Equal(0xA740DA0D, new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue); - Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue); - Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue); + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 0, 255); + + // act + rg32.ToRgba32(ref actual); + + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToVector4() + public void Rg32_ToBgr24() { - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4())); + // arrange + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 0); + + // act + rg32.ToBgr24(ref actual); + + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToScaledVector4() + public void Rg32_ToArgb32() { // arrange - var short4 = new NormalizedByte4(-Vector4.One); + var rg32 = new Rg32(0.1f, -0.3f); + var actual = default(Argb32); + var expected = new Argb32(25, 0, 0, 255); // act - Vector4 scaled = short4.ToScaledVector4(); + rg32.ToArgb32(ref actual); // assert - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(0, scaled.W); + Assert.Equal(expected, actual); + } + + [Fact] + public void Rgba1010102_PackedValue() + { + float x = 0x2db; + float y = 0x36d; + float z = 0x3b7; + float w = 0x1; + Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); + + Assert.Equal((uint)536871014, new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); + + // Test the limits. + Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); + } + + [Fact] + public void Rgba1010102_ToVector4() + { + Assert.Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4()); + Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4()); } [Fact] - public void NormalizedByte4_PackFromScaledVector4() + public void Rgba1010102_ToScaledVector4() { // arrange - var pixel = default(NormalizedByte4); - Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4(); + var rgba = new Rgba1010102(Vector4.One); - // act - pixel.PackFromScaledVector4(scaled); + // act + Vector4 actual = rgba.ToScaledVector4(); // assert - var expectedPackedValue = 0x81818181; - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void NormalizedByte4_ToRgb24() + public void Rgba1010102_PackFromScaledVector4() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var rgb24 = default(Rgb24); + var rgba = new Rgba1010102(Vector4.One); + var actual = default(Rgba1010102); + uint expected = 0xFFFFFFFF; // act - short4.ToRgb24(ref rgb24); + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); // assert - var expectedRgb24 = new Rgb24(141, 90, 192); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual.PackedValue); } [Fact] - public void NormalizedByte4_ToRgba32() + public void Rgba1010102_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4())); + } + + [Fact] + public void Rgba1010102_ToRgb24() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var rgba32 = default(Rgba32); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(25, 0, 128); // act - short4.ToRgba32(ref rgba32); + rgba.ToRgb24(ref actual); // assert - var expectedRgba32 = new Rgba32(141, 90, 192, 39); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToBgr24() + public void Rgba1010102_ToRgba32() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var bgr24 = default(Bgr24); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(25, 0, 128, 0); // act - short4.ToBgr24(ref bgr24); + rgba.ToRgba32(ref actual); // assert - var expectedBgr24 = new Bgr24(141, 90, 192); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_ToArgb32() + public void Rgba1010102_ToBgr24() { // arrange - var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f); - var argb32 = default(Argb32); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(25, 0, 128); // act - short4.ToArgb32(ref argb32); + rgba.ToBgr24(ref actual); // assert - var expectedArgb32 = new Argb32(141, 90, 192, 39); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromRgba32_ToRgba32() + public void Rgba1010102_ToBgra32() { // arrange - var rgba32 = default(Rgba32); - var short4 = default(NormalizedByte4); + var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(25, 0, 128, 0); - // act - short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - short4.ToRgba32(ref rgba32); + // act + rgba.ToBgra32(ref actual); // assert - var expectedRgba32 = new Rgba32(9, 115, 202, 127); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromBgra32_ToRgba32() + public void Rgba1010102_PackFromRgba32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); - var short4 = default(NormalizedByte4); - var expectedBgra32 = new Bgra32(9, 115, 202, 127); + var rgba = default(Rgba1010102); + var expected = new Rgba32(25, 0, 128, 0); + var actual = default(Rgba32); - // act - short4.PackFromBgra32(expectedBgra32); - short4.ToBgra32(ref bgra32); + // act + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); // assert - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedByte4_PackFromArgb32_ToRgba32() + public void Rgba1010102_PackFromBgra32_ToBgra32() { // arrange - var argb32 = default(Argb32); - var short4 = default(NormalizedByte4); + var rgba = default(Rgba1010102); + var expected = new Bgra32(25, 0, 128, 0); + var actual = default(Bgra32); - // act - short4.PackFromArgb32(new Argb32(9, 115, 202, 127)); - short4.ToArgb32(ref argb32); + // act + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(9, 115, 202, 127); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort2() + public void Rgba1010102_PackFromArgb32_ToArgb32() { - Assert.Equal((uint)0x0, new NormalizedShort2(Vector2.Zero).PackedValue); - Assert.Equal((uint)0x7FFF7FFF, new NormalizedShort2(Vector2.One).PackedValue); - Assert.Equal(0x80018001, new NormalizedShort2(-Vector2.One).PackedValue); - - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.Zero, new NormalizedShort2(Vector2.Zero).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(-Vector2.One).ToVector2())); - Assert.True(Equal(Vector2.One, new NormalizedShort2(Vector2.One * 1234.0f).ToVector2())); - Assert.True(Equal(-Vector2.One, new NormalizedShort2(Vector2.One * -1234.0f).ToVector2())); - - Assert.True(Equal(new Vector4(1, 1, 0, 1), (new NormalizedShort2(Vector2.One)).ToVector4())); - Assert.True(Equal(new Vector4(0, 0, 0, 1), (new NormalizedShort2(Vector2.Zero)).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4(); - Assert.Equal(0, scaled.X); - Assert.Equal(0, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(NormalizedShort2); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0x80018001, pixel.PackedValue); - - // Test Ordering - float x = 0.35f; - float y = -0.2f; - Assert.Equal(0xE6672CCC, new NormalizedShort2(x, y).PackedValue); - x = 0.1f; - y = -0.3f; - Assert.Equal(3650751693, new NormalizedShort2(x, y).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - var n = new NormalizedShort2(); - n.PackFromRgba32(new Rgba32(141, 90, 0, 0)); - n.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); - - // TODO: I don't think this can ever pass since the bytes are already truncated. - // Assert.Equal(3650751693, n.PackedValue); - - new NormalizedShort2(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(141, 90, 0)); - - new NormalizedShort2(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(141, 90, 0, 255)); - - new NormalizedShort2(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(141, 90, 0)); + // arrange + var rgba = default(Rgba1010102); + var expected = new Argb32(25, 0, 128, 0); + var actual = default(Argb32); - new NormalizedShort2(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(141, 90, 0, 255)); + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); - new NormalizedShort2(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(141, 90, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackedValues() + public void Rgba32_PackedValues() { - Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f).PackedValue); - Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue); - Assert.Equal((ulong)0x0, new NormalizedShort4(Vector4.Zero).PackedValue); - Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new NormalizedShort4(Vector4.One).PackedValue); - Assert.Equal(0x8001800180018001, new NormalizedShort4(-Vector4.One).PackedValue); + Assert.Equal(0x80001Au, new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f).PackedValue); + // Test the limits. + Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); } [Fact] - public void NormalizedShort4_ToVector4() + public void Rgba32_ToVector4() { - // Test ToVector4 - Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new NormalizedShort4(Vector4.Zero).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedShort4(-Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One * 1234.0f).ToVector4())); - Assert.True(Equal(-Vector4.One, new NormalizedShort4(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4())); + Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4())); + Assert.True(Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4())); + Assert.True(Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4())); + Assert.True(Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4())); + Assert.True(Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4())); } [Fact] - public void NormalizedShort4_ToScaledVector4() + public void Rgba32_ToScaledVector4() { // arrange - var short4 = new NormalizedShort4(Vector4.One); + var rgba = new Rgba32(Vector4.One); // act - Vector4 scaled = short4.ToScaledVector4(); + Vector4 actual = rgba.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void NormalizedShort4_PackFromScaledVector4() + public void Rgba32_PackFromScaledVector4() { // arrange - var pixel = default(NormalizedShort4); - Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); + var rgba = new Rgba32(Vector4.One); + var actual = default(Rgba32); + uint expected = 0xFFFFFFFF; - // act - pixel.PackFromScaledVector4(scaled); + // act + Vector4 scaled = rgba.ToScaledVector4(); + actual.PackFromScaledVector4(scaled); // assert - var expectedPackedValue = (ulong)0x7FFF7FFF7FFF7FFF; - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(expected, actual.PackedValue); } [Fact] - public void NormalizedShort4_ToRgb24() + public void Rgba32_Clamping() + { + Assert.Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4()); + Assert.Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4()); + } + + [Fact] + public void Rgba32_ToRgb24() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var rgb24 = default(Rgb24); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgb24); + var expected = new Rgb24(0x1a, 0, 0x80); // act - short4.ToRgb24(ref rgb24); + rgba.ToRgb24(ref actual); // assert - var expectedRgb24 = new Rgb24(141, 90, 192); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToRgba32() + public void Rgba32_ToRgba32() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var rgba32 = default(Rgba32); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); // act - short4.ToRgba32(ref rgba32); + rgba.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(141, 90, 192, 39); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToBgr24() + public void Rgba32_ToBgr24() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var bgr24 = default(Bgr24); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgr24); + var expected = new Bgr24(0x1a, 0, 0x80); // act - short4.ToBgr24(ref bgr24); + rgba.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(141, 90, 192); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_ToArgb32() + public void Rgba32_ToBgra32() { // arrange - var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f); - var argb32 = default(Argb32); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); // act - short4.ToArgb32(ref argb32); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(141, 90, 192, 39); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromRgba32_ToRgba32() + public void Rgba32_ToArgb32() { // arrange - var rgba32 = default(Rgba32); - var short4 = default(NormalizedShort4); + var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - // act - short4.PackFromRgba32(new Rgba32(9, 115, 202, 127)); - short4.ToRgba32(ref rgba32); + // act + rgba.ToArgb32(ref actual); // assert - var expectedRgba32 = new Rgba32(9, 115, 202, 127); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromBgra32_ToRgba32() + public void Rgba32_PackFromRgba32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); - var short4 = default(NormalizedShort4); + var rgba = default(Rgba32); + var actual = default(Rgba32); + var expected = new Rgba32(0x1a, 0, 0x80, 0); // act - short4.PackFromBgra32(new Bgra32(9, 115, 202, 127)); - short4.ToBgra32(ref bgra32); + rgba.PackFromRgba32(expected); + rgba.ToRgba32(ref actual); // assert - var expectedBgra32 = new Bgra32(9, 115, 202, 127); - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] - public void NormalizedShort4_PackFromArgb32_ToRgba32() + public void Rgba32_PackFromBgra32_ToRgba32() { // arrange - var argb32 = default(Argb32); - var short4 = default(NormalizedShort4); + var rgba = default(Rgba32); + var actual = default(Bgra32); + var expected = new Bgra32(0x1a, 0, 0x80, 0); // act - short4.PackFromArgb32(new Argb32(9, 115, 202, 127)); - short4.ToArgb32(ref argb32); + rgba.PackFromBgra32(expected); + rgba.ToBgra32(ref actual); // assert - var expectedArgb32 = new Argb32(9, 115, 202, 127); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } [Fact] - public void Rg32() + public void Rgba32_PackFromArgb32_ToArgb32() { - // Test the limits. - Assert.Equal((uint)0x0, new Rg32(Vector2.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rg32(Vector2.One).PackedValue); - - // Test ToVector2 - Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.Zero).ToVector2())); - Assert.True(Equal(Vector2.One, new Rg32(Vector2.One).ToVector2())); - - // Test ToScaledVector4. - Vector4 scaled = new Rg32(Vector2.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(Rg32); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2())); - Assert.True(Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2())); - - // Test Ordering - float x = 0xb6dc; - float y = 0xA59f; - Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue); - x = 0.1f; - y = -0.3f; - Assert.Equal((uint)6554, new Rg32(x, y).PackedValue); - - // Test ordering - var rgb = default(Rgb24); + // arrange var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Rg32(x, y).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 0)); - - new Rg32(x, y).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 0, 255)); - - new Rg32(x, y).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 0)); + var actual = default(Argb32); + var expected = new Argb32(0x1a, 0, 0x80, 0); - new Rg32(x, y).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 0, 255)); + // act + rgba.PackFromArgb32(expected); + rgba.ToArgb32(ref actual); - new Rg32(x, y).ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 0, 255)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Rgba1010102() + public void Rgba64_PackedValues() { + Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(0.08f, 0.15f, 0.30f, 0.45f).PackedValue); // Test the limits. - Assert.Equal((uint)0x0, new Rgba1010102(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba1010102(Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Rgba1010102(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); - - // Test PackFromScaledVector4. - var pixel = default(Rgba1010102); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba1010102(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4())); - - // Test Ordering - float x = 0x2db; - float y = 0x36d; - float z = 0x3b7; - float w = 0x1; - Assert.Equal((uint)0x7B7DB6DB, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue); - x = 0.1f; - y = -0.3f; - z = 0.5f; - w = -0.7f; - Assert.Equal((uint)536871014, new Rgba1010102(x, y, z, w).PackedValue); - - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - new Rgba1010102(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(25, 0, 128)); - - new Rgba1010102(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 128, 0)); - - new Rgba1010102(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(25, 0, 128)); + Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); + Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); + // Test data ordering + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); + Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); + } - new Rgba1010102(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); + [Fact] + public void Rgba64_ToVector4() + { + Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); + } - // Alpha component accuracy will be awful. - var r = default(Rgba1010102); - r.PackFromRgba32(new Rgba32(25, 0, 128, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(25, 0, 128, 0)); + [Fact] + public void Rgba64_ToScaledVector4() + { + // arrange + var short2 = new Rgba64(Vector4.One); - r = default(Rgba1010102); - r.PackFromBgra32(new Bgra32(25, 0, 128, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(25, 0, 128, 0)); + // act + Vector4 actual = short2.ToScaledVector4(); - r = default(Rgba1010102); - r.PackFromArgb32(new Argb32(25, 0, 128, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(25, 0, 128, 0)); + // assert + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] - public void Rgba32() + public void Rgba64_PackFromScaledVector4() { - // Test the limits. - Assert.Equal((uint)0x0, new Rgba32(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFF, new Rgba32(Vector4.One).PackedValue); - - // Test ToVector4. - Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One).ToVector4())); - Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.UnitX, new Rgba32(Vector4.UnitX).ToVector4())); - Assert.True(Equal(Vector4.UnitY, new Rgba32(Vector4.UnitY).ToVector4())); - Assert.True(Equal(Vector4.UnitZ, new Rgba32(Vector4.UnitZ).ToVector4())); - Assert.True(Equal(Vector4.UnitW, new Rgba32(Vector4.UnitW).ToVector4())); - - // Test ToScaledVector4. - Vector4 scaled = new Rgba32(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // arrange + var pixel = default(Rgba64); + var short4 = new Rgba64(Vector4.One); + ulong expected = 0xFFFFFFFFFFFFFFFF; - // Test PackFromScaledVector4. - var pixel = default(Rgba32); + // act + Vector4 scaled = short4.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFF, pixel.PackedValue); - - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba32(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba32(Vector4.One * +1234.0f).ToVector4())); - - float x = +0.1f; - float y = -0.3f; - float z = +0.5f; - float w = -0.7f; - var rgba32 = new Rgba32(x, y, z, w); - Assert.Equal(0x80001Au, rgba32.PackedValue); - - // Test ordering - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); - var argb = default(Argb32); - - rgba32.ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80)); - - rgba32.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); - Assert.Equal(rgba, rgba.ToRgba32()); - - rgba32.ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80)); + ulong actual = pixel.PackedValue; - rgba32.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); - Assert.Equal(bgra, bgra.ToBgra32()); + // assert + Assert.Equal(expected, actual); + } - rgba32.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); - Assert.Equal(argb, argb.ToArgb32()); + [Fact] + public void Rgba64_Clamping() + { + Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4())); + Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4())); + } - var r = default(Rgba32); - r.PackFromRgba32(new Rgba32(0x1a, 0, 0x80, 0)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0)); + [Fact] + public void Rgba64_ToRgb24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgb24); + var expected = new Rgb24(20, 38, 76); - r = default(Rgba32); - r.PackFromBgra32(new Bgra32(0x1a, 0, 0x80, 0)); - r.ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0)); + // act + rgba64.ToRgb24(ref actual); - r = default(Rgba32); - r.PackFromArgb32(new Argb32(0x1a, 0, 0x80, 0)); - r.ToArgb32(ref argb); - Assert.Equal(argb, new Argb32(0x1a, 0, 0x80, 0)); + // assert + Assert.Equal(expected, actual); } [Fact] - public void Rgba64() + public void Rgba64_ToRgba32() { - // Test the limits. - Assert.Equal((ulong)0x0, new Rgba64(Vector4.Zero).PackedValue); - Assert.Equal(0xFFFFFFFFFFFFFFFF, new Rgba64(Vector4.One).PackedValue); - - // Test ToVector4 - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.Zero).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One).ToVector4())); + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); - // Test ToScaledVector4. - Vector4 scaled = new Rgba64(Vector4.One).ToScaledVector4(); - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + // act + rgba64.ToRgba32(ref actual); - // Test PackFromScaledVector4. - var pixel = default(Rgba64); - pixel.PackFromScaledVector4(scaled); - Assert.Equal(0xFFFFFFFFFFFFFFFF, pixel.PackedValue); + // assert + Assert.Equal(expected, actual); + } - // Test clamping. - Assert.True(Equal(Vector4.Zero, new Rgba64(Vector4.One * -1234.0f).ToVector4())); - Assert.True(Equal(Vector4.One, new Rgba64(Vector4.One * 1234.0f).ToVector4())); + [Fact] + public void Rgba64_ToBgr24() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgr24); + var expected = new Bgr24(20, 38, 76); - // Test data ordering - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(((float)0x1EB8) / 0xffff, ((float)0x570A) / 0xffff, ((float)0x8F5C) / 0xffff, ((float)0xC7AD) / 0xffff).PackedValue); - Assert.Equal(0xC7AD8F5C570A1EB8, new Rgba64(0.12f, 0.34f, 0.56f, 0.78f).PackedValue); + // act + rgba64.ToBgr24(ref actual); - float x = 0.08f; - float y = 0.15f; - float z = 0.30f; - float w = 0.45f; - Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(x, y, z, w).PackedValue); + // assert + Assert.Equal(expected, actual); + } - var rgb = default(Rgb24); - var rgba = default(Rgba32); - var bgr = default(Bgr24); - var bgra = default(Bgra32); + [Fact] + public void Rgba64_ToBgra32() + { + // arrange + var rgba64 = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 76, 115); - new Rgba64(x, y, z, w).ToRgb24(ref rgb); - Assert.Equal(rgb, new Rgb24(20, 38, 76)); + // act + rgba64.ToBgra32(ref actual); - new Rgba64(x, y, z, w).ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 76, 115)); + // assert + Assert.Equal(expected, actual); + } - new Rgba64(x, y, z, w).ToBgr24(ref bgr); - Assert.Equal(bgr, new Bgr24(20, 38, 76)); + [Fact] + public void Rgba64_PackFromRgba32_ToRgba32() + { + // arrange + var rgba64 = default(Rgba64); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 76, 115); - new Rgba64(x, y, z, w).ToBgra32(ref bgra); - Assert.Equal(bgra, new Bgra32(20, 38, 76, 115)); + // act + rgba64.PackFromRgba32(expected); + rgba64.ToRgba32(ref actual); - var r = default(Rgba64); - r.PackFromRgba32(new Rgba32(20, 38, 76, 115)); - r.ToRgba32(ref rgba); - Assert.Equal(rgba, new Rgba32(20, 38, 76, 115)); + // assert + Assert.Equal(expected, actual); } [Fact] @@ -1397,13 +2759,13 @@ namespace SixLabors.ImageSharp.Tests.Colors var short2 = new Short2(Vector2.One * 0x7FFF); // act - Vector4 scaled = short2.ToScaledVector4(); + Vector4 actual = short2.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(0, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(0, actual.Z); + Assert.Equal(1, actual.W); } [Fact] @@ -1412,14 +2774,15 @@ namespace SixLabors.ImageSharp.Tests.Colors // arrange var pixel = default(Short2); var short2 = new Short2(Vector2.One * 0x7FFF); - ulong expectedPackedValue = 0x7FFF7FFF; + ulong expected = 0x7FFF7FFF; // act Vector4 scaled = short2.ToScaledVector4(); pixel.PackFromScaledVector4(scaled); + uint actual = pixel.PackedValue; // assert - Assert.Equal(expectedPackedValue, pixel.PackedValue); + Assert.Equal(expected, actual); } [Fact] @@ -1427,14 +2790,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var rgb24 = default(Rgb24); - var expectedRgb24 = new Rgb24(128, 127, 0); + var actual = default(Rgb24); + var expected = new Rgb24(128, 127, 0); // act - short2.ToRgb24(ref rgb24); + short2.ToRgb24(ref actual); // assert - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] @@ -1442,14 +2805,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var rgba32 = default(Rgba32); - var expectedRgba32 = new Rgba32(128, 127, 0, 255); + var actual = default(Rgba32); + var expected = new Rgba32(128, 127, 0, 255); // act - short2.ToRgba32(ref rgba32); + short2.ToRgba32(ref actual); // assert - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1457,14 +2820,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var bgr24 = default(Bgr24); + var actual = default(Bgr24); + var expected = new Bgr24(128, 127, 0); // act - short2.ToBgr24(ref bgr24); + short2.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(128, 127, 0); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] @@ -1472,14 +2835,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var argb32 = default(Argb32); - var expectedArgb32 = new Argb32(128, 127, 0, 255); + var actual = default(Argb32); + var expected = new Argb32(128, 127, 0, 255); // act - short2.ToArgb32(ref argb32); + short2.ToArgb32(ref actual); // assert - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] @@ -1487,30 +2850,30 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var short2 = new Short2(127.5f, -5.3f); - var bgra32 = default(Bgra32); - var expectedBgra32 = new Bgra32(128, 127, 0, 255); + var actual = default(Bgra32); + var expected = new Bgra32(128, 127, 0, 255); // act - short2.ToBgra32(ref bgra32); + short2.ToBgra32(ref actual); // assert - Assert.Equal(expectedBgra32, bgra32); + Assert.Equal(expected, actual); } [Fact] public void Short2_PackFromRgba32_ToRgba32() { // arrange - var rgba32 = default(Rgba32); var short2 = default(Short2); - var expectedRgba32 = new Rgba32(20, 38, 0, 255); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); // act - short2.PackFromRgba32(expectedRgba32); - short2.ToRgba32(ref rgba32); + short2.PackFromRgba32(expected); + short2.ToRgba32(ref actual); // assert - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1519,10 +2882,8 @@ namespace SixLabors.ImageSharp.Tests.Colors var shortValue1 = new Short4(11547, 12653, 29623, 193); var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f); - ulong expectedPackedValue1 = 0x00c173b7316d2d1b; - ulong expectedPackedValue2 = 18446462598732840960; - Assert.Equal(expectedPackedValue1, shortValue1.PackedValue); - Assert.Equal(expectedPackedValue2, shortValue2.PackedValue); + Assert.Equal((ulong)0x00c173b7316d2d1b, shortValue1.PackedValue); + Assert.Equal(18446462598732840960, shortValue2.PackedValue); Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue); Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue); Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue); @@ -1531,7 +2892,6 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Short4_ToVector4() { - // Test ToVector4. Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4()); Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4()); Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4()); @@ -1544,41 +2904,39 @@ namespace SixLabors.ImageSharp.Tests.Colors [Fact] public void Short4_ToScaledVector4() { - // Test ToScaledVector4. // arrange var short4 = new Short4(Vector4.One * 0x7FFF); // act - Vector4 scaled = short4.ToScaledVector4(); + Vector4 actual = short4.ToScaledVector4(); // assert - Assert.Equal(1, scaled.X); - Assert.Equal(1, scaled.Y); - Assert.Equal(1, scaled.Z); - Assert.Equal(1, scaled.W); + Assert.Equal(1, actual.X); + Assert.Equal(1, actual.Y); + Assert.Equal(1, actual.Z); + Assert.Equal(1, actual.W); } [Fact] public void Short4_PackFromScaledVector4() { - // Test PackFromScaledVector4. // arrange var short4 = new Short4(Vector4.One * 0x7FFF); Vector4 scaled = short4.ToScaledVector4(); + long expected = 0x7FFF7FFF7FFF7FFF; // act var pixel = default(Short4); pixel.PackFromScaledVector4(scaled); + ulong actual = pixel.PackedValue; // assert - long expectedPackedValue = 0x7FFF7FFF7FFF7FFF; - Assert.Equal((ulong)expectedPackedValue, pixel.PackedValue); + Assert.Equal((ulong)expected, pixel.PackedValue); } [Fact] public void Short4_Clamping() { - // Test clamping. // arrange var short1 = new Short4(Vector4.One * 1234567.0f); var short2 = new Short4(Vector4.One * -1234567.0f); @@ -1597,14 +2955,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var rgb24 = default(Rgb24); + var actual = default(Rgb24); + var expected = new Rgb24(172, 177, 243); // act - shortValue.ToRgb24(ref rgb24); + shortValue.ToRgb24(ref actual); // assert - var expectedRgb24 = new Rgb24(172, 177, 243); - Assert.Equal(expectedRgb24, rgb24); + Assert.Equal(expected, actual); } [Fact] @@ -1612,14 +2970,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var bgr24 = default(Bgr24); + var actual = default(Bgr24); + var expected = new Bgr24(172, 177, 243); // act - shortValue.ToBgr24(ref bgr24); + shortValue.ToBgr24(ref actual); // assert - var expectedBgr24 = new Bgr24(172, 177, 243); - Assert.Equal(expectedBgr24, bgr24); + Assert.Equal(expected, actual); } [Fact] @@ -1627,14 +2985,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var rgba32 = default(Rgba32); + var actual = default(Rgba32); + var expected = new Rgba32(172, 177, 243, 128); // act - shortValue.ToRgba32(ref rgba32); + shortValue.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(172, 177, 243, 128); - Assert.Equal(expectedRgba32, rgba32); + Assert.Equal(expected, actual); } [Fact] @@ -1642,14 +3000,14 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var bgra32 = default(Bgra32); + var actual = default(Bgra32); + var expected = new Bgra32(172, 177, 243, 128); // act - shortValue.ToBgra32(ref bgra32); + shortValue.ToBgra32(ref actual); // assert - var expectedBgra32 = new Bgra32(172, 177, 243, 128); - Assert.Equal(expectedBgra32, bgra32); + Assert.Equal(expected, actual); } [Fact] @@ -1657,62 +3015,62 @@ namespace SixLabors.ImageSharp.Tests.Colors { // arrange var shortValue = new Short4(11547, 12653, 29623, 193); - var argb32 = default(Argb32); + var actual = default(Argb32); + var expected = new Argb32(172, 177, 243, 128); // act - shortValue.ToArgb32(ref argb32); + shortValue.ToArgb32(ref actual); // assert - var expectedArgb32 = new Argb32(172, 177, 243, 128); - Assert.Equal(expectedArgb32, argb32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromRgba32_ToRgba32() { // arrange - var rgba32 = default(Rgba32); var short4 = default(Short4); + var actual = default(Rgba32); + var expected = new Rgba32(20, 38, 0, 255); // act - short4.PackFromRgba32(new Rgba32(20, 38, 0, 255)); - short4.ToRgba32(ref rgba32); + short4.PackFromRgba32(expected); + short4.ToRgba32(ref actual); // assert - var expectedRgba32 = new Rgba32(20, 38, 0, 255); - Assert.Equal(rgba32, expectedRgba32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromBgra32_ToRgba32() { // arrange - var bgra32 = default(Bgra32); var short4 = default(Short4); + var actual = default(Bgra32); + var expected = new Bgra32(20, 38, 0, 255); // act - short4.PackFromBgra32(new Bgra32(20, 38, 0, 255)); - short4.ToBgra32(ref bgra32); + short4.PackFromBgra32(expected); + short4.ToBgra32(ref actual); // assert - var expectedBgra32 = new Bgra32(20, 38, 0, 255); - Assert.Equal(bgra32, expectedBgra32); + Assert.Equal(expected, actual); } [Fact] public void Short4_PackFromArgb32_ToRgba32() { // arrange - var argb32 = default(Argb32); var short4 = default(Short4); + var actual = default(Argb32); + var expected = new Argb32(20, 38, 0, 255); // act - short4.PackFromArgb32(new Argb32(20, 38, 0, 255)); - short4.ToArgb32(ref argb32); + short4.PackFromArgb32(expected); + short4.ToArgb32(ref actual); // assert - var expectedArgb32 = new Argb32(20, 38, 0, 255); - Assert.Equal(argb32, expectedArgb32); + Assert.Equal(expected, actual); } // Comparison helpers with small tolerance to allow for floating point rounding during computations.