private List<int>[] IndexLookupTable;

        public void CreateIndexReverseLookup(SpherizedCubed mesh)
        {
            IndexLookupTable = new List<int>[mesh.Vertices.Length];

            for (int i = 0; i < mesh.Vertices.Length; i ++)
            {
                IndexLookupTable[i] = new List<int>();
            }

            for (int i = 0; i < mesh.Indices.Length; i += 3)
            {
                for (int j = 0; j < 3; j++)
                {
                    IndexLookupTable[mesh.Indices[i + j]].Add(i + j);
                }
            }
        }

        public List<int[]> lookupTrianglesAttachedToVertex(int vertexIndex)
        {
            List<int[]> triangles = new List<int[]>();

            foreach (int index in IndexLookupTable[vertexIndex])
            {
                int[] triangle = new int[3];

                int i1;
                int i2;
                int i3;

                if (index % 3 == 0)
                {
                    i1 = index;
                    i2 = index + 1;
                    i3 = index + 2;
                } else if ((index - 1) % 3 == 0)
                {
                    i1 = index - 1;
                    i2 = index;
                    i3 = index + 1;
                } else {
                    i1 = index - 2;
                    i2 = index - 1;
                    i3 = index;
                }

                triangle[0] = i1;
                triangle[1] = i2;
                triangle[2] = i3;

                triangles.Add(triangle);
            }

            return triangles;
        }

        private void RecalculateNormals(Terrain terrain, List<int> uniqueVertexIndex)
        {
            List<int[]> totalTriangles = new List<int[]>();
            List<int> verticesToNormalize = new List<int>();
            foreach (int vertexIndex in uniqueVertexIndex)
            {
                Console.WriteLine("Vertex Position Changed: " + vertexIndex);
                foreach (int[] triangle in terrain.Collider.lookupTrianglesAttachedToVertex(vertexIndex))
                {
                    bool skip = false;
                    foreach (int[] testTriangle in totalTriangles)
                        if (triangle[0] == testTriangle[0])
                        {
                            skip = true;
                        }
                    if (!skip)
                    {
                        totalTriangles.Add(triangle);
                        foreach (int index in triangle)
                        {
                            if (!verticesToNormalize.Contains(terrain.Mesh.Indices[index]))
                            {
                                verticesToNormalize.Add(terrain.Mesh.Indices[index]);
                            }
                        }
                    }
                }
            }

            foreach (int vertex in verticesToNormalize)
            {
                terrain.Mesh.Vertices[vertex].Normal = new Vector3(0, 0, 0);
                Console.WriteLine("Vertex Updating: " + vertex);
            }

            foreach (int[] triangle in totalTriangles)
            {
                int index1 = terrain.Mesh.Indices[triangle[0]];
                int index2 = terrain.Mesh.Indices[triangle[1]];
                int index3 = terrain.Mesh.Indices[triangle[2]];
                Vector3 side1 = terrain.Mesh.Vertices[index3].Position - terrain.Mesh.Vertices[index2].Position;
                Vector3 side2 = terrain.Mesh.Vertices[index2].Position - terrain.Mesh.Vertices[index1].Position;
                Vector3 normal = Vector3.Cross(side1, side2);

                terrain.Mesh.Vertices[index1].Normal += normal;
                terrain.Mesh.Vertices[index2].Normal += normal;
                terrain.Mesh.Vertices[index3].Normal += normal;

                Console.WriteLine("Recalculated Normals on Triangle: " + triangle[0] + " " + index1 + " | " + triangle[1] + " " + index2 + " | " + triangle[2] + " " + index3);

            }

            foreach (int vertex in verticesToNormalize)
               terrain.Mesh.Vertices[vertex].Normal.Normalize();

        }