public void ReadWriteHalfTest(int format, uint redMask, uint greenMask, uint blueMask, uint alphaMask)
        {
            const int numberOfVertices = 100;
              DataFormat vertexElementFormat = (DataFormat)format;
              int bytesPerElement = DirectXMesh.BytesPerElement(vertexElementFormat);
              Assert.Greater(bytesPerElement, 0);

              var vertexDeclaration = new[]
              {
            new VertexElement(VertexElementSemantic.Position, 0, vertexElementFormat, -1),
            new VertexElement(VertexElementSemantic.Normal, 0, vertexElementFormat, -1)
              };
              var vbAccessor = new VertexBufferAccessor(vertexDeclaration);

              var positions = new Vector4F[numberOfVertices];
              for (int i = 0; i < positions.Length; i++)
            positions[i] = new Vector4F(
              i / (float)numberOfVertices,
              (i + 10) / (float)numberOfVertices,
              (i + 20) / (float)numberOfVertices,
              (i + 30) / (float)numberOfVertices);

              var normals = new Vector4F[numberOfVertices];
              for (int i = 0; i < normals.Length; i++)
            normals[i] = new Vector4F(
              (i + 40) / (float)numberOfVertices,
              (i + 50) / (float)numberOfVertices,
              (i + 60) / (float)numberOfVertices,
              (i + 70) / (float)numberOfVertices);

              vbAccessor.SetElements(positions, VertexElementSemantic.Position, 0);
              vbAccessor.SetElements(normals, VertexElementSemantic.Normal, 0);

              byte[] vb;
              int n;
              int stride;
              vbAccessor.GetStream(0, out vb, out n, out stride);

              Assert.NotNull(vb);
              Assert.AreEqual(numberOfVertices, n);
              Assert.AreEqual(2 * bytesPerElement, stride);
              Assert.AreEqual(stride * n, vb.Length);

              vbAccessor = new VertexBufferAccessor(vertexDeclaration);
              vbAccessor.SetStream(0, vb, numberOfVertices);

              var positions1 = new Vector4F[numberOfVertices];
              var normals1 = new Vector4F[numberOfVertices];
              vbAccessor.GetElements(positions1, VertexElementSemantic.Position, 0);
              vbAccessor.GetElements(normals1, VertexElementSemantic.Normal, 0);

              for (int i = 0; i < positions.Length; i++)
              {
            Vector4F expected = AsHalf(positions[i], redMask, greenMask, blueMask, alphaMask);
            Assert.AreEqual(expected.X, positions1[i].X);
            Assert.AreEqual(expected.Y, positions1[i].Y);
            Assert.AreEqual(expected.Z, positions1[i].Z);
            Assert.AreEqual(expected.W, positions1[i].W);
              }

              for (int i = 0; i < normals.Length; i++)
              {
            Vector4F expected = AsHalf(normals[i], redMask, greenMask, blueMask, alphaMask);
            Assert.AreEqual(expected.X, normals1[i].X);
            Assert.AreEqual(expected.Y, normals1[i].Y);
            Assert.AreEqual(expected.Z, normals1[i].Z);
            Assert.AreEqual(expected.W, normals1[i].W);
              }
        }
Пример #2
0
        public void ReadWriteHalfTest(int format, uint redMask, uint greenMask, uint blueMask, uint alphaMask)
        {
            const int  numberOfVertices    = 100;
            DataFormat vertexElementFormat = (DataFormat)format;
            int        bytesPerElement     = DirectXMesh.BytesPerElement(vertexElementFormat);

            Assert.Greater(bytesPerElement, 0);

            var vertexDeclaration = new[]
            {
                new VertexElement(VertexElementSemantic.Position, 0, vertexElementFormat, -1),
                new VertexElement(VertexElementSemantic.Normal, 0, vertexElementFormat, -1)
            };
            var vbAccessor = new VertexBufferAccessor(vertexDeclaration);

            var positions = new Vector4F[numberOfVertices];

            for (int i = 0; i < positions.Length; i++)
            {
                positions[i] = new Vector4F(
                    i / (float)numberOfVertices,
                    (i + 10) / (float)numberOfVertices,
                    (i + 20) / (float)numberOfVertices,
                    (i + 30) / (float)numberOfVertices);
            }

            var normals = new Vector4F[numberOfVertices];

            for (int i = 0; i < normals.Length; i++)
            {
                normals[i] = new Vector4F(
                    (i + 40) / (float)numberOfVertices,
                    (i + 50) / (float)numberOfVertices,
                    (i + 60) / (float)numberOfVertices,
                    (i + 70) / (float)numberOfVertices);
            }

            vbAccessor.SetElements(positions, VertexElementSemantic.Position, 0);
            vbAccessor.SetElements(normals, VertexElementSemantic.Normal, 0);

            byte[] vb;
            int    n;
            int    stride;

            vbAccessor.GetStream(0, out vb, out n, out stride);

            Assert.NotNull(vb);
            Assert.AreEqual(numberOfVertices, n);
            Assert.AreEqual(2 * bytesPerElement, stride);
            Assert.AreEqual(stride * n, vb.Length);

            vbAccessor = new VertexBufferAccessor(vertexDeclaration);
            vbAccessor.SetStream(0, vb, numberOfVertices);

            var positions1 = new Vector4F[numberOfVertices];
            var normals1   = new Vector4F[numberOfVertices];

            vbAccessor.GetElements(positions1, VertexElementSemantic.Position, 0);
            vbAccessor.GetElements(normals1, VertexElementSemantic.Normal, 0);

            for (int i = 0; i < positions.Length; i++)
            {
                Vector4F expected = AsHalf(positions[i], redMask, greenMask, blueMask, alphaMask);
                Assert.AreEqual(expected.X, positions1[i].X);
                Assert.AreEqual(expected.Y, positions1[i].Y);
                Assert.AreEqual(expected.Z, positions1[i].Z);
                Assert.AreEqual(expected.W, positions1[i].W);
            }

            for (int i = 0; i < normals.Length; i++)
            {
                Vector4F expected = AsHalf(normals[i], redMask, greenMask, blueMask, alphaMask);
                Assert.AreEqual(expected.X, normals1[i].X);
                Assert.AreEqual(expected.Y, normals1[i].Y);
                Assert.AreEqual(expected.Z, normals1[i].Z);
                Assert.AreEqual(expected.W, normals1[i].W);
            }
        }