public void GenerateTextSmoothAngle()
        {
            var mesh = new An8Mesh();

            mesh.SmoothAngleThreshold = 2.0f;

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 2.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
  }
  faces {
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
Example #2
0
        public void ParseNormalsAndTexCoords()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
faces {
  3 7 4 5 ( ( 10 11 12 ) ( 13 14 15 ) ( 16 17 18 ) )
}
");

            var face = mesh.Faces[0];

            Assert.True(face.IsBackShown);
            Assert.True(face.HasNormalIndexes);
            Assert.True(face.HasTexCoordIndexes);
            Assert.Equal(3, face.PointIndexes.Length);
            Assert.Equal(3, face.NormalIndexes.Length);
            Assert.Equal(3, face.TexCoordIndexes.Length);
            Assert.Equal(4, face.MaterialIndex);
            Assert.Equal(5, face.FlatNormalIndex);
            Assert.Equal(10, face.PointIndexes[0]);
            Assert.Equal(11, face.NormalIndexes[0]);
            Assert.Equal(12, face.TexCoordIndexes[0]);
            Assert.Equal(13, face.PointIndexes[1]);
            Assert.Equal(14, face.NormalIndexes[1]);
            Assert.Equal(15, face.TexCoordIndexes[1]);
            Assert.Equal(16, face.PointIndexes[2]);
            Assert.Equal(17, face.NormalIndexes[2]);
            Assert.Equal(18, face.TexCoordIndexes[2]);
        }
        public void GenerateTextMaterialList()
        {
            var mesh = new An8Mesh();

            mesh.MaterialList.Add("abc");

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
    materialname { ""abc"" }
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
  }
  faces {
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
Example #4
0
        public void ParsePoints()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
faces {
  3 0 4 5 ( ( 10 ) ( 13 ) ( 16 ) )
}
");

            var face = mesh.Faces[0];

            Assert.False(face.IsBackShown);
            Assert.False(face.HasNormalIndexes);
            Assert.False(face.HasTexCoordIndexes);
            Assert.Equal(3, face.PointIndexes.Length);
            Assert.Null(face.NormalIndexes);
            Assert.Null(face.TexCoordIndexes);
            Assert.Equal(4, face.MaterialIndex);
            Assert.Equal(5, face.FlatNormalIndex);
            Assert.Equal(10, face.PointIndexes[0]);
            Assert.Equal(13, face.PointIndexes[1]);
            Assert.Equal(16, face.PointIndexes[2]);
        }
        public void GenerateTextTexCoords()
        {
            var mesh = new An8Mesh();

            mesh.TexCoords.Add(new An8TexCoord {
                U = 2.0f, V = 3.0f
            });

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
    ( 2.000000 3.000000 )
  }
  faces {
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
        public void GenerateTextFaces()
        {
            var mesh = new An8Mesh();

            mesh.Faces.Add(new An8Face());

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
  }
  faces {
    0 0 0 0 ( )
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
        public void ParseEmpty()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
");
        }
        public void ParseOther()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
other { }
");
        }
        public void ParseMaterial()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
material { }
");

            Assert.NotNull(mesh.Material);
        }
        public void ParseSmoothAngle()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
smoothangle { 2.0 }
");

            Assert.Equal(2.0f, mesh.SmoothAngleThreshold);
        }
Example #11
0
        public void ParseEmpty()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
faces {
  0 0 0 0 ( )
}
");

            var face = mesh.Faces[0];
        }
        public void NewMesh()
        {
            var mesh = new An8Mesh();

            Assert.Null(mesh.Material);
            Assert.Equal(0.0f, mesh.SmoothAngleThreshold);
            Assert.NotNull(mesh.MaterialList);
            Assert.NotNull(mesh.Points);
            Assert.NotNull(mesh.Normals);
            Assert.NotNull(mesh.Edges);
            Assert.NotNull(mesh.TexCoords);
            Assert.NotNull(mesh.Faces);
        }
        public void ParseFaces()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
faces {
  0 0 0 0 ( )
}
");

            Assert.Equal(1, mesh.Faces.Count);
        }
        public void ParseMaterialListClear()
        {
            var mesh = new An8Mesh();

            mesh.MaterialList.Add(null);

            mesh.Parse(
                @"
materiallist {
}
");

            Assert.Equal(0, mesh.MaterialList.Count);
        }
        public void ParseMaterialList()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
materiallist {
  materialname { ""abc"" }
}
");

            Assert.Equal(1, mesh.MaterialList.Count);
            Assert.Equal("abc", mesh.MaterialList[0]);
        }
        public void ParsePointsClear()
        {
            var mesh = new An8Mesh();

            mesh.Points.Add(new An8Point());

            mesh.Parse(
                @"
points {
}
");

            Assert.Equal(0, mesh.Points.Count);
        }
        public void ParseNormalsClear()
        {
            var mesh = new An8Mesh();

            mesh.Normals.Add(new An8Point());

            mesh.Parse(
                @"
normals {
}
");

            Assert.Equal(0, mesh.Normals.Count);
        }
        public void ParseFacesClear()
        {
            var mesh = new An8Mesh();

            mesh.Faces.Add(new An8Face());

            mesh.Parse(
                @"
faces {
}
");

            Assert.Equal(0, mesh.Faces.Count);
        }
        public void ParseTexCoordsClear()
        {
            var mesh = new An8Mesh();

            mesh.TexCoords.Add(new An8TexCoord());

            mesh.Parse(
                @"
texcoords {
}
");

            Assert.Equal(0, mesh.TexCoords.Count);
        }
        public void ParseEdgesClear()
        {
            var mesh = new An8Mesh();

            mesh.Edges.Add(new An8Edge());

            mesh.Parse(
                @"
edges {
}
");

            Assert.Equal(0, mesh.Edges.Count);
        }
        public void ParseTexCoords()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
texcoords {
  ( 2.0 3.0 )
}
");

            Assert.Equal(1, mesh.TexCoords.Count);
            Assert.Equal(2.0f, mesh.TexCoords[0].U);
            Assert.Equal(3.0f, mesh.TexCoords[0].V);
        }
        public void ParsePoints()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
points {
  ( 2.0 3.0 4.0 )
}
");

            Assert.Equal(1, mesh.Points.Count);
            Assert.Equal(2.0f, mesh.Points[0].X);
            Assert.Equal(3.0f, mesh.Points[0].Y);
            Assert.Equal(4.0f, mesh.Points[0].Z);
        }
        public void ParseNormals()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
normals {
  ( 2.0 3.0 4.0 )
}
");

            Assert.Equal(1, mesh.Normals.Count);
            Assert.Equal(2.0f, mesh.Normals[0].X);
            Assert.Equal(3.0f, mesh.Normals[0].Y);
            Assert.Equal(4.0f, mesh.Normals[0].Z);
        }
Example #24
0
        public void GenerateTextNormalsAndTexCoords()
        {
            var face = new An8Face();

            face.IsBackShown     = true;
            face.MaterialIndex   = 4;
            face.FlatNormalIndex = 5;
            face.PointIndexes    = new int[] { 10, 13, 16 };
            face.NormalIndexes   = new int[] { 11, 14, 17 };
            face.TexCoordIndexes = new int[] { 12, 15, 18 };

            var mesh = new An8Mesh();

            mesh.Faces.Add(face);

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
  }
  faces {
    3 7 4 5 ( ( 10 11 12 ) ( 13 14 15 ) ( 16 17 18 ) )
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
        public void ParseEdges()
        {
            var mesh = new An8Mesh();

            mesh.Parse(
                @"
edges {
  ( 2 3 )
  ( 4 5 6 )
}
");

            Assert.Equal(2, mesh.Edges.Count);
            Assert.Equal(2, mesh.Edges[0].Index1);
            Assert.Equal(3, mesh.Edges[0].Index2);
            Assert.False(mesh.Edges[0].Sharpness.HasValue);
            Assert.Equal(4, mesh.Edges[1].Index1);
            Assert.Equal(5, mesh.Edges[1].Index2);
            Assert.True(mesh.Edges[1].Sharpness.HasValue);
            Assert.Equal(6, mesh.Edges[1].Sharpness.Value);
        }
Example #26
0
        public void GenerateTextPoints()
        {
            var face = new An8Face();

            face.MaterialIndex   = 4;
            face.FlatNormalIndex = 5;
            face.PointIndexes    = new int[] { 10, 13, 16 };

            var mesh = new An8Mesh();

            mesh.Faces.Add(face);

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
  }
  texcoords {
  }
  faces {
    3 0 4 5 ( ( 10 ) ( 13 ) ( 16 ) )
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
        public void GenerateTextEdges()
        {
            var mesh = new An8Mesh();

            mesh.Edges.Add(new An8Edge {
                Index1 = 2, Index2 = 3
            });
            mesh.Edges.Add(new An8Edge {
                Index1 = 4, Index2 = 5, Sharpness = 6
            });

            var text = mesh.GenerateText();

            string expected =
                @"mesh {
  name { """" }
  smoothangle { 0.000000 }
  materiallist {
  }
  points {
  }
  normals {
  }
  edges {
    ( 2 3 )
    ( 4 5 6 )
  }
  texcoords {
  }
  faces {
  }
}
";

            Assert.Equal(
                expected.Replace("\r\n", "\n"),
                text.Replace("\r\n", "\n"));
        }
Example #28
0
        public static void OptToAn8(OptFile opt, string an8Path, bool scale)
        {
            if (opt == null)
            {
                throw new ArgumentNullException("opt");
            }

            string an8Directory = Path.GetDirectoryName(an8Path);
            string an8Name      = Path.GetFileNameWithoutExtension(an8Path);

            foreach (var texture in opt.Textures.Values)
            {
                texture.Save(Path.Combine(an8Directory, string.Concat(texture.Name, ".png")));
            }

            var distances = opt.Meshes
                            .SelectMany(t => t.Lods)
                            .Select(t => t.Distance)
                            .Distinct()
                            .OrderByDescending(t => t)
                            .ToArray();

            for (int distance = 0; distance < distances.Length; distance++)
            {
                var an8 = new An8File();

                foreach (var texture in opt.Textures.Values)
                {
                    var an8Texture = new An8Texture();
                    an8Texture.Name = texture.Name;
                    an8Texture.Files.Add(string.Concat(texture.Name, ".png"));
                    an8.Textures.Add(an8Texture);

                    var an8Material = new An8Material();
                    an8Material.Name                 = texture.Name;
                    an8Material.FrontSurface         = new An8Surface();
                    an8Material.FrontSurface.Diffuse = new An8MaterialColor
                    {
                        TextureName   = texture.Name,
                        TextureParams = new An8TextureParams
                        {
                            AlphaMode = texture.HasAlpha ? An8AlphaMode.Final : An8AlphaMode.None,
                            BlendMode = An8BlendMode.Darken
                        }
                    };

                    an8.Materials.Add(an8Material);
                }

                var an8Object = new An8Object();
                an8Object.Name = Path.GetFileNameWithoutExtension(opt.FileName);
                an8.Objects.Add(an8Object);

                int objectsIndex = 0;

                foreach (var mesh in opt.Meshes)
                {
                    var lod = mesh.Lods.FirstOrDefault(t => t.Distance <= distances[distance]);

                    if (lod == null)
                    {
                        continue;
                    }

                    var an8Mesh = new An8Mesh();
                    an8Mesh.Name = string.Format(CultureInfo.InvariantCulture, "{0}.{1:D3}", mesh.Descriptor.MeshType, objectsIndex);
                    an8Object.Components.Add(an8Mesh);
                    objectsIndex++;

                    foreach (var texture in mesh.Lods
                             .SelectMany(t => t.FaceGroups)
                             .SelectMany(t => t.Textures)
                             .Distinct())
                    {
                        an8Mesh.MaterialList.Add(texture);
                    }

                    if (scale)
                    {
                        foreach (var v in mesh.Vertices)
                        {
                            an8Mesh.Points.Add(new An8Point
                            {
                                X = v.X * OptFile.ScaleFactor,
                                Y = v.Z * OptFile.ScaleFactor,
                                Z = v.Y * OptFile.ScaleFactor
                            });
                        }
                    }
                    else
                    {
                        foreach (var v in mesh.Vertices)
                        {
                            an8Mesh.Points.Add(new An8Point
                            {
                                X = v.X,
                                Y = v.Z,
                                Z = v.Y
                            });
                        }
                    }


                    foreach (var v in mesh.TextureCoordinates)
                    {
                        an8Mesh.TexCoords.Add(new An8TexCoord
                        {
                            U = v.U,
                            V = -v.V
                        });
                    }

                    foreach (var v in mesh.VertexNormals)
                    {
                        an8Mesh.Normals.Add(new An8Point
                        {
                            X = v.X,
                            Y = v.Z,
                            Z = v.Y
                        });
                    }

                    int verticesIndex       = 0;
                    int verticesTexIndex    = 0;
                    int verticesNormalIndex = 0;

                    foreach (var faceGroup in lod.FaceGroups)
                    {
                        int materialIndex = 0;

                        if (faceGroup.Textures.Count > 0)
                        {
                            materialIndex = an8Mesh.MaterialList.IndexOf(faceGroup.Textures[0]);
                        }

                        foreach (var face in faceGroup.Faces)
                        {
                            if (face.VerticesIndex.D < 0)
                            {
                                var an8Face = new An8Face
                                {
                                    MaterialIndex   = materialIndex,
                                    FlatNormalIndex = -1
                                };

                                an8Face.PointIndexes = new int[]
                                {
                                    verticesIndex + face.VerticesIndex.A,
                                    verticesIndex + face.VerticesIndex.B,
                                    verticesIndex + face.VerticesIndex.C
                                };

                                an8Face.TexCoordIndexes = new int[]
                                {
                                    verticesTexIndex + face.TextureCoordinatesIndex.A,
                                    verticesTexIndex + face.TextureCoordinatesIndex.B,
                                    verticesTexIndex + face.TextureCoordinatesIndex.C
                                };

                                an8Face.NormalIndexes = new int[]
                                {
                                    verticesNormalIndex + face.VertexNormalsIndex.A,
                                    verticesNormalIndex + face.VertexNormalsIndex.B,
                                    verticesNormalIndex + face.VertexNormalsIndex.C
                                };

                                an8Mesh.Faces.Add(an8Face);
                            }
                            else
                            {
                                var an8Face = new An8Face
                                {
                                    MaterialIndex   = materialIndex,
                                    FlatNormalIndex = -1
                                };

                                an8Face.PointIndexes = new int[]
                                {
                                    verticesIndex + face.VerticesIndex.A,
                                    verticesIndex + face.VerticesIndex.B,
                                    verticesIndex + face.VerticesIndex.C,
                                    verticesIndex + face.VerticesIndex.D
                                };

                                an8Face.TexCoordIndexes = new int[]
                                {
                                    verticesTexIndex + face.TextureCoordinatesIndex.A,
                                    verticesTexIndex + face.TextureCoordinatesIndex.B,
                                    verticesTexIndex + face.TextureCoordinatesIndex.C,
                                    verticesTexIndex + face.TextureCoordinatesIndex.D
                                };

                                an8Face.NormalIndexes = new int[]
                                {
                                    verticesNormalIndex + face.VertexNormalsIndex.A,
                                    verticesNormalIndex + face.VertexNormalsIndex.B,
                                    verticesNormalIndex + face.VertexNormalsIndex.C,
                                    verticesNormalIndex + face.VertexNormalsIndex.D
                                };

                                an8Mesh.Faces.Add(an8Face);
                            }
                        }
                    }

                    verticesIndex       += mesh.Vertices.Count;
                    verticesTexIndex    += mesh.TextureCoordinates.Count;
                    verticesNormalIndex += mesh.VertexNormals.Count;
                }

                an8.Save(Path.Combine(an8Directory, string.Format(CultureInfo.InvariantCulture, "{0}_{1}.an8", an8Name, distance)));
            }
        }
Example #29
0
        public static void OptToAn8(OptFile opt, string an8Path, bool scale)
        {
            if (opt == null)
            {
                throw new ArgumentNullException("opt");
            }

            string an8Directory = Path.GetDirectoryName(an8Path);
            string an8Name = Path.GetFileNameWithoutExtension(an8Path);

            foreach (var texture in opt.Textures.Values)
            {
                texture.Save(Path.Combine(an8Directory, string.Concat(texture.Name, ".png")));
            }

            var distances = opt.Meshes
                .SelectMany(t => t.Lods)
                .Select(t => t.Distance)
                .Distinct()
                .OrderByDescending(t => t)
                .ToArray();

            for (int distance = 0; distance < distances.Length; distance++)
            {
                var an8 = new An8File();

                foreach (var texture in opt.Textures.Values)
                {
                    var an8Texture = new An8Texture();
                    an8Texture.Name = texture.Name;
                    an8Texture.Files.Add(string.Concat(texture.Name, ".png"));
                    an8.Textures.Add(an8Texture);

                    var an8Material = new An8Material();
                    an8Material.Name = texture.Name;
                    an8Material.FrontSurface = new An8Surface();
                    an8Material.FrontSurface.Diffuse = new An8MaterialColor
                    {
                        TextureName = texture.Name,
                        TextureParams = new An8TextureParams
                        {
                            AlphaMode = texture.HasAlpha ? An8AlphaMode.Final : An8AlphaMode.None,
                            BlendMode = An8BlendMode.Darken
                        }
                    };

                    an8.Materials.Add(an8Material);
                }

                var an8Object = new An8Object();
                an8Object.Name = Path.GetFileNameWithoutExtension(opt.FileName);
                an8.Objects.Add(an8Object);

                int objectsIndex = 0;

                foreach (var mesh in opt.Meshes)
                {
                    var lod = mesh.Lods.FirstOrDefault(t => t.Distance <= distances[distance]);

                    if (lod == null)
                    {
                        continue;
                    }

                    var an8Mesh = new An8Mesh();
                    an8Mesh.Name = string.Format(CultureInfo.InvariantCulture, "{0}.{1:D3}", mesh.Descriptor.MeshType, objectsIndex);
                    an8Object.Components.Add(an8Mesh);
                    objectsIndex++;

                    foreach (var texture in mesh.Lods
                        .SelectMany(t => t.FaceGroups)
                        .SelectMany(t => t.Textures)
                        .Distinct())
                    {
                        an8Mesh.MaterialList.Add(texture);
                    }

                    if (scale)
                    {
                        foreach (var v in mesh.Vertices)
                        {
                            an8Mesh.Points.Add(new An8Point
                            {
                                X = v.X * OptFile.ScaleFactor,
                                Y = v.Z * OptFile.ScaleFactor,
                                Z = v.Y * OptFile.ScaleFactor
                            });
                        }
                    }
                    else
                    {
                        foreach (var v in mesh.Vertices)
                        {
                            an8Mesh.Points.Add(new An8Point
                            {
                                X = v.X,
                                Y = v.Z,
                                Z = v.Y
                            });
                        }
                    }

                    foreach (var v in mesh.TextureCoordinates)
                    {
                        an8Mesh.TexCoords.Add(new An8TexCoord
                        {
                            U = v.U,
                            V = -v.V
                        });
                    }

                    foreach (var v in mesh.VertexNormals)
                    {
                        an8Mesh.Normals.Add(new An8Point
                        {
                            X = v.X,
                            Y = v.Z,
                            Z = v.Y
                        });
                    }

                    int verticesIndex = 0;
                    int verticesTexIndex = 0;
                    int verticesNormalIndex = 0;

                    foreach (var faceGroup in lod.FaceGroups)
                    {
                        int materialIndex = 0;

                        if (faceGroup.Textures.Count > 0)
                        {
                            materialIndex = an8Mesh.MaterialList.IndexOf(faceGroup.Textures[0]);
                        }

                        foreach (var face in faceGroup.Faces)
                        {
                            if (face.VerticesIndex.D < 0)
                            {
                                var an8Face = new An8Face
                                {
                                    MaterialIndex = materialIndex,
                                    FlatNormalIndex = -1
                                };

                                an8Face.PointIndexes = new int[]
                                {
                                    verticesIndex + face.VerticesIndex.A,
                                    verticesIndex + face.VerticesIndex.B,
                                    verticesIndex + face.VerticesIndex.C
                                };

                                an8Face.TexCoordIndexes = new int[]
                                {
                                    verticesTexIndex + face.TextureCoordinatesIndex.A,
                                    verticesTexIndex + face.TextureCoordinatesIndex.B,
                                    verticesTexIndex + face.TextureCoordinatesIndex.C
                                };

                                an8Face.NormalIndexes = new int[]
                                {
                                    verticesNormalIndex + face.VertexNormalsIndex.A,
                                    verticesNormalIndex + face.VertexNormalsIndex.B,
                                    verticesNormalIndex + face.VertexNormalsIndex.C
                                };

                                an8Mesh.Faces.Add(an8Face);
                            }
                            else
                            {
                                var an8Face = new An8Face
                                {
                                    MaterialIndex = materialIndex,
                                    FlatNormalIndex = -1
                                };

                                an8Face.PointIndexes = new int[]
                                {
                                    verticesIndex + face.VerticesIndex.A,
                                    verticesIndex + face.VerticesIndex.B,
                                    verticesIndex + face.VerticesIndex.C,
                                    verticesIndex + face.VerticesIndex.D
                                };

                                an8Face.TexCoordIndexes = new int[]
                                {
                                    verticesTexIndex + face.TextureCoordinatesIndex.A,
                                    verticesTexIndex + face.TextureCoordinatesIndex.B,
                                    verticesTexIndex + face.TextureCoordinatesIndex.C,
                                    verticesTexIndex + face.TextureCoordinatesIndex.D
                                };

                                an8Face.NormalIndexes = new int[]
                                {
                                    verticesNormalIndex + face.VertexNormalsIndex.A,
                                    verticesNormalIndex + face.VertexNormalsIndex.B,
                                    verticesNormalIndex + face.VertexNormalsIndex.C,
                                    verticesNormalIndex + face.VertexNormalsIndex.D
                                };

                                an8Mesh.Faces.Add(an8Face);
                            }
                        }
                    }

                    verticesIndex += mesh.Vertices.Count;
                    verticesTexIndex += mesh.TextureCoordinates.Count;
                    verticesNormalIndex += mesh.VertexNormals.Count;
                }

                an8.Save(Path.Combine(an8Directory, string.Format(CultureInfo.InvariantCulture, "{0}_{1}.an8", an8Name, distance)));
            }
        }