示例

STL文件格式

solid AutoCAD
   facet normal -0.906285 -0.422666 -0.000000
      outer loop
         vertex 0.440247 1.736237 -29.300010
         vertex 0.440247 1.736237 -29.495010
         vertex 0.522675 1.559494 -29.300010
      endloop
   endfacet
   facet normal -0.906285 -0.422666 0.000000
      outer loop
         vertex 0.440247 1.736237 -29.300010
         vertex 0.522675 1.559494 -29.300010
         vertex 0.440247 1.736237 -29.105010
      endloop
   endfacet
endsolid AutoCAD

STLFile.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

/// <summary>
/// 解析STL文件
/// </summary>
public class STLFile
{
    private static readonly string[] separator = new string[] { " " };

    public static Mesh LoadFromFile(string path, bool optimization = true)
    {
        if (!File.Exists(path))
            return null;
        string[] lines = File.ReadAllLines(path);
        int size = lines.Length;
        int startIndex = 0;
        int skipIndex = 0;
        List<SolidObject> solids = new List<SolidObject>();
        while (startIndex < size)
        {
            SolidObject solid = ParseSolidObject(lines, startIndex, out skipIndex);
            solids.Add(solid);
            startIndex = skipIndex;
        }

        Mesh mesh = solids[0].ToMesh(optimization);

        return mesh;
    }

    // 第一行的第一个单词为类型
    private static string ParseLineType(string line)
    {
        string[] words = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
        return words[0];
    }

    // 解析solid Object
    private static SolidObject ParseSolidObject(string[] lines, int startIndex, out int skipIndex)
    {
        startIndex++; //skip solid ObjectXX line
        List<Facet> facets = new List<Facet>();
        while (true)
        {
            Facet facet = ParseFacet(lines, startIndex);
            facets.Add(facet);
            startIndex += 7;
            if (ParseLineType(lines[startIndex]).StartsWith("endsolid"))
            {
                skipIndex = startIndex + 1;//跳到下一个solid object
                break;
            }
        }
        SolidObject solid = new SolidObject();
        solid.facets = facets;
        return solid;
    }

    // 解析facet块
    private static Facet ParseFacet(string[] lines, int startIndex)
    {
        string normal_line = lines[startIndex];
        string v0_line = lines[startIndex + 2];
        string v1_line = lines[startIndex + 3];
        string v2_line = lines[startIndex + 4];

        Facet facet = new Facet();
        facet.normal = ParseNormalLine(normal_line);
        facet.triangle = ParseTriangleLine(v0_line, v1_line, v2_line);
        return facet;
    }

    // 解析facet块法线
    private static Vector3 ParseNormalLine(string line)
    {
        string[] words = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
        float x = float.Parse(words[2]);
        float y = float.Parse(words[3]);
        float z = float.Parse(words[4]);
        return new Vector3(x, y, z);
    }

    // 解析单个顶点坐标行
    private static Vector3 ParseVertexLine(string line)
    {
        string[] words = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
        float x = float.Parse(words[1]);
        float y = float.Parse(words[2]);
        float z = float.Parse(words[3]);
        return new Vector3(x, y, z);
    }

    // 解析out loop块的三角形顶点坐标
    private static Vector3[] ParseTriangleLine(string line0, string line1, string line2)
    {
        Vector3 v0 = ParseVertexLine(line0);
        Vector3 v1 = ParseVertexLine(line1);
        Vector3 v2 = ParseVertexLine(line2);
        return new Vector3[] { v0, v1, v2 };
    }

    // 面
    class Facet
    {
        public Vector3 normal;
        public Vector3[] triangle;
    }

    // 实体
    class SolidObject
    {
        public List<Facet> facets;

        private List<Vector3> GetNormals()
        {
            List<Vector3> normals = new List<Vector3>();
            for (int i = 0; i < facets.Count; i++)
            {
                normals.Add(facets[i].normal);
                normals.Add(facets[i].normal);
                normals.Add(facets[i].normal);
            }
            return normals;
        }

        private List<Vector3> GetVertices(out int[] indices)
        {
            indices = new int[facets.Count * 3];
            List<Vector3> vertices = new List<Vector3>();
            int j = 0;
            for(int i=0; i<facets.Count; i++)
            {
                vertices.AddRange(facets[i].triangle);
                indices[j] = j++;
                indices[j] = j++;
                indices[j] = j++;
            }
            return vertices;
        }

        // 去除重复顶点
        private List<Vector3> RemoveRedundance(List<Vector3> vertices, int[] indices, List<Vector3> normals, out int[] indicesOpt, out List<Vector3> normalsOpt)
        {
            normalsOpt = new List<Vector3>();
            List<Vector3> new_vertices = new List<Vector3>();
            List<int> new_indices = new List<int>();
            Dictionary<string, int> vdic = new Dictionary<string, int>();
            int j = 0;
            for (int i=0; i<vertices.Count; i++)
            {
                Vector3 v = vertices[i];
                string key = v.ToString();
                if (vdic.ContainsKey(key))
                {
                    int index = vdic[key];
                    new_indices.Add(index);
                }
                else
                {
                    vdic.Add(key, j);
                    new_vertices.Add(v);
                    new_indices.Add(j++);
                    normalsOpt.Add(normals[i]);
                }
            }
            indicesOpt = new_indices.ToArray();
            return new_vertices;
        }

        public Mesh ToMesh(bool optimization = true)
        {
            Mesh m = new Mesh();
            int[] indices;
            int[] indices_opt;
            List<Vector3> normals = GetNormals();
            List<Vector3> vertices = GetVertices(out indices);
            if (optimization)
            {
                List<Vector3> normals_opt = new List<Vector3>();
                List<Vector3> vertices_opt = RemoveRedundance(vertices, indices, normals, out indices_opt, out normals_opt);
                //Debug.LogFormat("vertices.Count={0}, vertices_opt.Count={1}, normals_opt.Count={2}, indices.Length={3}, indices_opt.Length={4}",
                    //vertices.Count, vertices_opt.Count, normals_opt.Count, indices.Length, indices_opt.Length);
                m.SetVertices(vertices_opt);
                m.SetNormals(normals_opt);
                m.triangles = indices_opt;
            }
            else
            {
                m.SetVertices(vertices);
                m.SetNormals(normals);
                m.triangles = indices;
            }
            return m;
        }
    }
}

STLFile_Test.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class STLFile_Test : MonoBehaviour
{
    public MeshFilter meshFilter;
    public string stlFile;
    public bool optimization = true;
    public int vertexCount = 0;
    public int triangleCount = 0;

    // Start is called before the first frame update
    void Start()
    {
        meshFilter.mesh = STLFile.LoadFromFile(stlFile, optimization);
        vertexCount = meshFilter.mesh.vertexCount;
        triangleCount = meshFilter.mesh.triangles.Length / 3;
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

运行效果