예제 #1
0
        public void Encode(VertexElement element, XNAV4 value)
        {
            var dstVertex = _Vertex.Slice(element.Offset);

            if (element.VertexElementFormat == VertexElementFormat.Vector4)
            {
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref value);
                return;
            }

            if (element.VertexElementFormat == VertexElementFormat.Byte4)
            {
                var c = new Byte4(value);
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref c);
                return;
            }

            if (element.VertexElementFormat == VertexElementFormat.Color)
            {
                var c = new Color(value);
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref c);
                return;
            }

            if (element.VertexElementFormat == VertexElementFormat.Short4)
            {
                var ns = new Short4(value);
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref ns);
                return;
            }

            if (element.VertexElementFormat == VertexElementFormat.NormalizedShort4)
            {
                var ns = new NormalizedShort4(value);
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref ns);
                return;
            }

            if (element.VertexElementFormat == VertexElementFormat.HalfVector4)
            {
                var ns = new HalfVector4(value);
                System.Runtime.InteropServices.MemoryMarshal.Write(dstVertex, ref ns);
                return;
            }

            throw new ArgumentException(nameof(element));
        }
        public void NormalizedShort4()
        {
            // Test 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 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 = 0.1f;
            float y = -0.3f;
            float z = 0.5f;
            float w = -0.7f;

            Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
            Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);

            byte[] rgb  = new byte[3];
            byte[] rgba = new byte[4];
            byte[] bgr  = new byte[3];
            byte[] bgra = new byte[4];

            new NormalizedShort4(x, y, z, w).ToXyzBytes(rgb, 0);
            Assert.Equal(rgb, new byte[] { 141, 90, 192 });

            new NormalizedShort4(x, y, z, w).ToXyzwBytes(rgba, 0);
            Assert.Equal(rgba, new byte[] { 141, 90, 192, 39 });

            new NormalizedShort4(x, y, z, w).ToZyxBytes(bgr, 0);
            Assert.Equal(bgr, new byte[] { 192, 90, 141 });

            new NormalizedShort4(x, y, z, w).ToZyxwBytes(bgra, 0);
            Assert.Equal(bgra, new byte[] { 192, 90, 141, 39 });

            NormalizedShort4 r = new NormalizedShort4();

            r.PackFromBytes(9, 115, 202, 127);
            r.ToXyzwBytes(rgba, 0);
            Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
        }
예제 #3
0
        public void NormalizedShort4()
        {
            // Test 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 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 = 0.1f;
            float y = -0.3f;
            float z = 0.5f;
            float w = -0.7f;

            Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
            Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);

            var rgb  = default(Rgb24);
            var rgba = default(Rgba32);
            var bgr  = default(Bgr24);
            var bgra = default(Bgra32);

            new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
            Assert.Equal(rgb, new Rgb24(141, 90, 192));

            new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
            Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));

            new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
            Assert.Equal(bgr, new Bgr24(141, 90, 192));

            new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
            Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));

            var r = new NormalizedShort4();

            r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
            r.ToRgba32(ref rgba);
            Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
        }
예제 #4
0
        public void NormalizedShort4()
        {
            // Test PackedValue
            Assert.Equal(0x0UL, new NormalizedShort4(Vector4.Zero).PackedValue);
            Assert.Equal(0x7FFF7FFF7FFF7FFFUL, new NormalizedShort4(Vector4.One).PackedValue);
            Assert.Equal(0x8001800180018001, new NormalizedShort4(-Vector4.One).PackedValue);

            // 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 ToScaledVector4.
            Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();

            Assert.Equal(1, scaled.X);
            Assert.Equal(1, scaled.Y);
            Assert.Equal(1, scaled.Z);
            Assert.Equal(1, scaled.W);

            // Test FromScaledVector4.
            var pixel = default(NormalizedShort4);

            pixel.FromScaledVector4(scaled);
            Assert.Equal(0x7FFF7FFF7FFF7FFFUL, pixel.PackedValue);

            // Test Ordering
            float x = 0.1f;
            float y = -0.3f;
            float z = 0.5f;
            float w = -0.7f;

            Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
            Assert.Equal(4150390751449251866UL, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);

            // var rgb = default(Rgb24);
            // var rgba = default(Rgba32);
            // var bgr = default(Bgr24);
            // var bgra = default(Bgra32);
            // var argb = default(Argb32);

            // new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
            // Assert.Equal(rgb, new Rgb24(141, 90, 192));

            // new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
            // Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594)

            // new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
            // Assert.Equal(bgr, new Bgr24(141, 90, 192));

            // new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
            // Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));

            // new NormalizedShort4(x, y, z, w).ToArgb32(ref argb);
            // Assert.Equal(argb, new Argb32(141, 90, 192, 39));

            // var r = default(NormalizedShort4);
            // r.FromRgba32(new Rgba32(9, 115, 202, 127));
            // r.ToRgba32(ref rgba);
            // Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));

            // r = default(NormalizedShort4);
            // r.FromBgra32(new Bgra32(9, 115, 202, 127));
            // r.ToBgra32(ref bgra);
            // Assert.Equal(bgra, new Bgra32(9, 115, 202, 127));

            // r = default(NormalizedShort4);
            // r.FromArgb32(new Argb32(9, 115, 202, 127));
            // r.ToArgb32(ref argb);
            // Assert.Equal(argb, new Argb32(9, 115, 202, 127));
        }