Esempio n. 1
0
        public void PlaneEqualsNanTest()
        {
            Plane a = new Plane(Single.NaN, 0, 0, 0);
            Plane b = new Plane(0, Single.NaN, 0, 0);
            Plane c = new Plane(0, 0, Single.NaN, 0);
            Plane d = new Plane(0, 0, 0, Single.NaN);

            Assert.False(a == new Plane(0, 0, 0, 0));
            Assert.False(b == new Plane(0, 0, 0, 0));
            Assert.False(c == new Plane(0, 0, 0, 0));
            Assert.False(d == new Plane(0, 0, 0, 0));

            Assert.True(a != new Plane(0, 0, 0, 0));
            Assert.True(b != new Plane(0, 0, 0, 0));
            Assert.True(c != new Plane(0, 0, 0, 0));
            Assert.True(d != new Plane(0, 0, 0, 0));

            Assert.False(a.Equals(new Plane(0, 0, 0, 0)));
            Assert.False(b.Equals(new Plane(0, 0, 0, 0)));
            Assert.False(c.Equals(new Plane(0, 0, 0, 0)));
            Assert.False(d.Equals(new Plane(0, 0, 0, 0)));

            // Counterintuitive result - IEEE rules for NaN comparison are weird!
            Assert.False(a.Equals(a));
            Assert.False(b.Equals(b));
            Assert.False(c.Equals(c));
            Assert.False(d.Equals(d));
        }
Esempio n. 2
0
        // Transform by matrix
        public void PlaneTransformTest1()
        {
            Plane target = new Plane(1, 2, 3, 4);

            target = Plane.Normalize(target);

            Matrix4x4 m =
                Matrix4x4.CreateRotationX(MathHelper.ToRadians(30.0f)) *
                Matrix4x4.CreateRotationY(MathHelper.ToRadians(30.0f)) *
                Matrix4x4.CreateRotationZ(MathHelper.ToRadians(30.0f));

            m.M41 = 10.0f;
            m.M42 = 20.0f;
            m.M43 = 30.0f;

            Plane     expected = new Plane();
            Matrix4x4 inv;

            Matrix4x4.Invert(m, out inv);
            Matrix4x4 itm = Matrix4x4.Transpose(inv);
            Single    x = target.Normal.X, y = target.Normal.Y, z = target.Normal.Z, w = target.D;

            expected.Normal = new Vector3(
                x * itm.M11 + y * itm.M21 + z * itm.M31 + w * itm.M41,
                x * itm.M12 + y * itm.M22 + z * itm.M32 + w * itm.M42,
                x * itm.M13 + y * itm.M23 + z * itm.M33 + w * itm.M43);
            expected.D = x * itm.M14 + y * itm.M24 + z * itm.M34 + w * itm.M44;

            Plane actual;

            actual = Plane.Transform(target, m);
            Assert.True(MathHelper.Equal(expected, actual), "Plane.Transform did not return the expected value.");
        }
Esempio n. 3
0
        // Transform by quaternion
        public void PlaneTransformTest2()
        {
            Plane target = new Plane(1, 2, 3, 4);

            target = Plane.Normalize(target);

            Matrix4x4 m =
                Matrix4x4.CreateRotationX(MathHelper.ToRadians(30.0f)) *
                Matrix4x4.CreateRotationY(MathHelper.ToRadians(30.0f)) *
                Matrix4x4.CreateRotationZ(MathHelper.ToRadians(30.0f));
            Quaternion q = Quaternion.CreateFromRotationMatrix(m);

            Plane  expected = new Plane();
            Single x = target.Normal.X, y = target.Normal.Y, z = target.Normal.Z, w = target.D;

            expected.Normal = new Vector3(
                x * m.M11 + y * m.M21 + z * m.M31 + w * m.M41,
                x * m.M12 + y * m.M22 + z * m.M32 + w * m.M42,
                x * m.M13 + y * m.M23 + z * m.M33 + w * m.M43);
            expected.D = x * m.M14 + y * m.M24 + z * m.M34 + w * m.M44;

            Plane actual;

            actual = Plane.Transform(target, q);
            Assert.True(MathHelper.Equal(expected, actual), "Plane.Transform did not return the expected value.");
        }
Esempio n. 4
0
        public void PlaneEqualsTest()
        {
            Plane a = new Plane(1.0f, 2.0f, 3.0f, 4.0f);
            Plane b = new Plane(1.0f, 2.0f, 3.0f, 4.0f);

            // case 1: compare between same values
            object obj = b;

            bool expected = true;
            bool actual   = a.Equals(obj);

            Assert.Equal(expected, actual);

            // case 2: compare between different values
            b.Normal = new Vector3(10.0f, b.Normal.Y, b.Normal.Z);

            obj      = b;
            expected = false;
            actual   = a.Equals(obj);
            Assert.Equal(expected, actual);

            // case 3: compare between different types.
            obj      = new Quaternion();
            expected = false;
            actual   = a.Equals(obj);
            Assert.Equal(expected, actual);

            // case 3: compare against null.
            obj      = null;
            expected = false;
            actual   = a.Equals(obj);
            Assert.Equal(expected, actual);
        }
Esempio n. 5
0
        public void PlaneConstructorTest1()
        {
            Single a = 1.0f, b = 2.0f, c = 3.0f, d = 4.0f;
            Plane  target = new Plane(a, b, c, d);

            Assert.True(
                target.Normal.X == a && target.Normal.Y == b && target.Normal.Z == c && target.D == d,
                "Plane.cstor did not return the expected value.");
        }
Esempio n. 6
0
        public void PlaneConstructorTest()
        {
            Vector4 value  = new Vector4(1.0f, 2.0f, 3.0f, 4.0f);
            Plane   target = new Plane(value);

            Assert.True(
                target.Normal.X == value.X && target.Normal.Y == value.Y && target.Normal.Z == value.Z && target.D == value.W,
                "Plane.cstor did not return the expected value.");
        }
Esempio n. 7
0
        public void PlaneGetHashCodeTest()
        {
            Plane target = new Plane(1.0f, 2.0f, 3.0f, 4.0f);

            int expected = target.Normal.GetHashCode() + target.D.GetHashCode();
            int actual   = target.GetHashCode();

            Assert.Equal(expected, actual);
        }
Esempio n. 8
0
        public void PlaneDotNormalTest()
        {
            Plane   target = new Plane(2, 3, 4, 5);
            Vector3 value  = new Vector3(5, 4, 3);

            Single expected = 10 + 12 + 12;
            Single actual   = Plane.DotNormal(target, value);

            Assert.True(MathHelper.Equal(expected, actual), "Plane.DotCoordinate returns unexpected value.");
        }
Esempio n. 9
0
        public void PlaneDotTest()
        {
            Plane   target = new Plane(2, 3, 4, 5);
            Vector4 value  = new Vector4(5, 4, 3, 2);

            Single expected = 10 + 12 + 12 + 10;
            Single actual   = Plane.Dot(target, value);

            Assert.True(MathHelper.Equal(expected, actual), "Plane.Dot returns unexpected value.");
        }
Esempio n. 10
0
        public void PlaneToStringTest()
        {
            Plane  target   = new Plane(1, 2, 3, 4);
            string expected = string.Format(
                CultureInfo.CurrentCulture,
                "{{Normal:{0:G} D:{1}}}",
                target.Normal,
                target.D);

            Assert.Equal(expected, target.ToString());
        }
Esempio n. 11
0
        public void PlaneConstructorTest3()
        {
            Vector3 normal = new Vector3(1, 2, 3);
            Single  d      = 4;

            Plane target = new Plane(normal, d);

            Assert.True(
                target.Normal == normal && target.D == d,
                "Plane.cstor did not return the expected value.");
        }
Esempio n. 12
0
        public void PlaneCreateFromVerticesTest()
        {
            Vector3 point1 = new Vector3(0.0f, 1.0f, 1.0f);
            Vector3 point2 = new Vector3(0.0f, 0.0f, 1.0f);
            Vector3 point3 = new Vector3(1.0f, 0.0f, 1.0f);

            Plane target   = Plane.CreateFromVertices(point1, point2, point3);
            Plane expected = new Plane(new Vector3(0, 0, 1), -1.0f);

            Assert.Equal(target, expected);
        }
Esempio n. 13
0
        public unsafe void PlaneFieldOffsetTest()
        {
            Plane plane = new Plane();

            Single *basePtr  = &plane.Normal.X; // Take address of first element
            Plane * planePtr = &plane;          // Take address of whole Plane

            Assert.Equal(new IntPtr(basePtr), new IntPtr(planePtr));

            Assert.Equal(new IntPtr(basePtr + 0), new IntPtr(&plane.Normal));
            Assert.Equal(new IntPtr(basePtr + 3), new IntPtr(&plane.D));
        }
Esempio n. 14
0
        public void PlaneCreateFromVerticesTest2()
        {
            Vector3 point1 = new Vector3(0.0f, 0.0f, 1.0f);
            Vector3 point2 = new Vector3(1.0f, 0.0f, 0.0f);
            Vector3 point3 = new Vector3(1.0f, 1.0f, 0.0f);

            Plane  target   = Plane.CreateFromVertices(point1, point2, point3);
            Single invRoot2 = (Single)(1 / Math.Sqrt(2));

            Plane expected = new Plane(new Vector3(invRoot2, 0, invRoot2), -invRoot2);

            Assert.True(MathHelper.Equal(target, expected), "Plane.cstor did not return the expected value.");
        }
Esempio n. 15
0
        public void PlaneNormalizeTest()
        {
            Plane target = new Plane(1, 2, 3, 4);

            Single f        = target.Normal.LengthSquared();
            Single invF     = 1.0f / (Single)Math.Sqrt(f);
            Plane  expected = new Plane(target.Normal * invF, target.D * invF);

            Plane actual = Plane.Normalize(target);

            Assert.True(MathHelper.Equal(expected, actual), "Plane.Normalize returns unexpected value.");

            // normalize, normalized normal.
            actual = Plane.Normalize(actual);
            Assert.True(MathHelper.Equal(expected, actual), "Plane.Normalize returns unexpected value.");
        }
Esempio n. 16
0
        public void PlaneEqualityTest()
        {
            Plane a = new Plane(1.0f, 2.0f, 3.0f, 4.0f);
            Plane b = new Plane(1.0f, 2.0f, 3.0f, 4.0f);

            // case 1: compare between same values
            bool expected = true;
            bool actual   = a == b;

            Assert.Equal(expected, actual);

            // case 2: compare between different values
            b.Normal = new Vector3(10.0f, b.Normal.Y, b.Normal.Z);
            expected = false;
            actual   = a == b;
            Assert.Equal(expected, actual);
        }
Esempio n. 17
0
 public static bool Equal(Plane a, Plane b)
 {
     return(Equal(a.Normal, b.Normal) && Equal(a.D, b.D));
 }