/// <summary>
        /// warning: cache thrashes
        /// </summary>
        /// <param name="mesh"></param>
        /// <param name="vertexes"></param>
        public static void ConvertMeshToVertList(Vector3[,] mesh, ref VertexPositionTexture[] vertexes)
        {
            int index = 0;
            for (int x = 0; x < mesh.GetLength(0) - 1; x++) {
                for (int z = 0; z < mesh.GetLength(1) - 1; z++) {
                    vertexes[index].Position = mesh[x, z];
                    vertexes[index + 1].Position = mesh[x, z + 1];
                    vertexes[index + 2].Position = mesh[x + 1, z + 1];
                    vertexes[index + 3].Position = mesh[x + 1, z];

                    index += 4;
                }
            }
        }
Esempio n. 2
0
        public static void ConvertMeshToVertList(Vector3[,] mesh, Vector3[,] normals, ref VertexPositionNormalTexture[] verticies)
        {
            //convert from 2d array to 1d
            int index = 0;
            for (int x = 0; x < mesh.GetLength(0) - 1; x++){
                for (int z = 0; z < mesh.GetLength(1) - 1; z++){
                    verticies[index].Position = mesh[x, z];
                    verticies[index].Normal = normals[x, z];

                    verticies[index + 1].Position = mesh[x, z + 1];
                    verticies[index + 1].Normal = normals[x, z + 1];

                    verticies[index + 2].Position = mesh[x + 1, z + 1];
                    verticies[index + 2].Normal = normals[x + 1, z + 1];

                    verticies[index + 3].Position = mesh[x + 1, z];
                    verticies[index + 3].Normal = normals[x + 1, z];

                    index += 4;
                }
            }
        }
        public static VertexPositionNormalTexture[] ConvertMeshToVertList(Vector3[,] mesh, Vector3[,] normals)
        {
            var vertLi = new VertexPositionNormalTexture[(mesh.GetLength(0) - 1) * (mesh.GetLength(1) - 1) * 4];
            //convert from 2d array to 1d
            int index = 0;
            for (int x = 0; x < mesh.GetLength(0) - 1; x++) {
                for (int z = 0; z < mesh.GetLength(1) - 1; z++) {
                    vertLi[index].Position = mesh[x, z];
                    vertLi[index].Normal = normals[x, z];

                    vertLi[index + 1].Position = mesh[x, z + 1];
                    vertLi[index + 1].Normal = normals[x, z + 1];

                    vertLi[index + 2].Position = mesh[x + 1, z + 1];
                    vertLi[index + 2].Normal = normals[x + 1, z + 1];

                    vertLi[index + 3].Position = mesh[x + 1, z];
                    vertLi[index + 3].Normal = normals[x + 1, z];

                    index += 4;
                }
            }
            return vertLi;
        }
        public static Vector3[,] GenerateMeshNormals(Vector3[,] mesh)
        {
            var normals = new Vector3[mesh.GetLength(0), mesh.GetLength(1)];
            for (int vertX = 0; vertX < mesh.GetLength(0) - 1; vertX++) {
                for (int vertZ = 0; vertZ < mesh.GetLength(1) - 1; vertZ++) {
                    var crossSum = new Vector3();

                    var s1 = mesh[vertX + 1, vertZ] - mesh[vertX, vertZ];
                    var s2 = mesh[vertX, vertZ + 1] - mesh[vertX, vertZ];
                    var s3 = mesh[vertX + 1, vertZ + 1] - mesh[vertX, vertZ];

                    crossSum += Vector3.Cross(s1, s3);
                    crossSum += Vector3.Cross(s3, s2);

                    normals[vertX, vertZ] += crossSum;
                    if (crossSum != Vector3.Zero) {
                        normals[vertX, vertZ].Normalize();
                    }
                }
            }

            for (int vertX = 1; vertX < mesh.GetLength(0); vertX++) {
                for (int vertZ = 1; vertZ < mesh.GetLength(1); vertZ++) {
                    var crossSum = new Vector3();

                    var s1 = mesh[vertX - 1, vertZ] - mesh[vertX, vertZ];
                    var s2 = mesh[vertX, vertZ - 1] - mesh[vertX, vertZ];
                    var s3 = mesh[vertX - 1, vertZ - 1] - mesh[vertX, vertZ];

                    crossSum += Vector3.Cross(s1, s3);
                    crossSum += Vector3.Cross(s3, s2);

                    normals[vertX, vertZ] += crossSum;
                    normals[vertX, vertZ].Normalize();
                }
            }
            return normals;
        }