运行时在Unity中解析超过65k个顶点的网格

Question

我正在尝试使用Unity和C#在运行时加载OBJ模型。我使用Unity的Wiki解析器"FastOBJImporter“http://wiki.unity3d.com/index.php/FastObjImporter来解析OBJ文件。我不能加载超过65,534个顶点的网格，因为它是单位限制( http://answers.unity3d.com/questions/471639/mesh-with-more-than-65000-vertices.html )

我的想法是将一个大的网格路径传递给FastOBJImporter，并生成多个顶点少于65k的GameObjects，以便加载更大的模型。

有谁知道如何安全地修改FastOBJimporter，以便返回子网格列表而不是大网格？欢迎任何其他解决方案/想法。

Answer 1

This script使用STL模型文件做您想要做的事情。它通过在每次达到65k顶点时将网格分割为子网格来导入模型，无论模型有多大。STL文件可以转换成OBJ文件，所以，我想，使用一个简单的转换器，或者修改脚本，就可以做到这一点。

下面的代码(我不接受任何代码)。

#pragma warning disable 0219

using UnityEngine;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Threading;

namespace Parabox.STL
{
    /*Import methods for STL files*/
    public class STL_ImportScript : MonoBehaviour
    {

        const int MAX_FACETS_PER_MESH = 65535 / 3;

        class Facet
        {
            public Vector3 normal;
            public Vector3 a, b, c;

            public override string ToString()
            {
                return string.Format("{0:F2}: {1:F2}, {2:F2}, {3:F2}", normal, a, b, c);
            }
        }

        /**
         * Import an STL file at path.
         */
        public static Mesh[] Import(string path)
        {
                try
                {
                    return ImportBinary(path);
                }
                catch (System.Exception e)
                {
                    UnityEngine.Debug.LogWarning(string.Format("Failed importing mesh at path {0}.\n{1}", path, e.ToString()));
                    return null;
                }
        }

        private static Mesh[] ImportBinary(string path)
        {
            List<Facet> facets = new List<Facet>();
            byte[] header;
            uint facetCount;

            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader br = new BinaryReader(fs, new ASCIIEncoding()))
                {
                    while (br.BaseStream.Position < br.BaseStream.Length)
                    {
                        // read header
                        header = br.ReadBytes(80);
                        facetCount = br.ReadUInt32();

                        for (uint i = 0; i < facetCount; i++)
                        {
                            try
                            {
                                Facet facet = new Facet();

                                facet.normal.x = br.ReadSingle();
                                facet.normal.y = br.ReadSingle();
                                facet.normal.z = br.ReadSingle();

                                facet.a.x = br.ReadSingle();
                                facet.a.y = br.ReadSingle();
                                facet.a.z = br.ReadSingle();

                                facet.b.x = br.ReadSingle();
                                facet.b.y = br.ReadSingle();
                                facet.b.z = br.ReadSingle();

                                facet.c.x = br.ReadSingle();
                                facet.c.y = br.ReadSingle();
                                facet.c.z = br.ReadSingle();

                                facets.Add(facet);


                                // padding
                                br.ReadUInt16();
                            }
                            catch (Exception e)
                            {
                                //Console.WriteLine(e.Message);
                                Debug.Log(e.Message);
                            }
                        }
                    }
                }
            }

            return CreateMeshWithFacets(facets);
        }

        const int SOLID = 1;
        const int FACET = 2;
        const int OUTER = 3;
        const int VERTEX = 4;
        const int ENDLOOP = 5;
        const int ENDFACET = 6;
        const int ENDSOLID = 7;
        const int EMPTY = 0;

        private static int ReadState(string line)
        {
            if (line.StartsWith("solid"))
                return SOLID;
            else if (line.StartsWith("facet"))
                return FACET;
            else if (line.StartsWith("outer"))
                return OUTER;
            else if (line.StartsWith("vertex"))
                return VERTEX;
            else if (line.StartsWith("endloop"))
                return ENDLOOP;
            else if (line.StartsWith("endfacet"))
                return ENDFACET;
            else if (line.StartsWith("endsolid"))
                return ENDSOLID;
            else
                return EMPTY;
        }

        private static Vector3 StringToVec3(string str)
        {
            string[] split = str.Trim().Split(null);
            Vector3 v = new Vector3();

            float.TryParse(split[0], out v.x);
            float.TryParse(split[1], out v.y);
            float.TryParse(split[2], out v.z);

            return v;
        }


        private static Mesh[] CreateMeshWithFacets(IList<Facet> facets)
        {
            int fl = facets.Count, f = 0, mvc = MAX_FACETS_PER_MESH * 3;
            Mesh[] meshes = new Mesh[fl / MAX_FACETS_PER_MESH + 1];

            for (int i = 0; i < meshes.Length; i++)
            {
                int len = System.Math.Min(mvc, (fl - f) * 3);
                Vector3[] v = new Vector3[len];
                Vector3[] n = new Vector3[len];
                int[] t = new int[len];

                for (int it = 0; it < len; it += 3)
                {
                    v[it] = facets[f].a;
                    v[it + 1] = facets[f].b;
                    v[it + 2] = facets[f].c;

                    n[it] = facets[f].normal;
                    n[it + 1] = facets[f].normal;
                    n[it + 2] = facets[f].normal;

                    t[it] = it;
                    t[it + 1] = it + 1;
                    t[it + 2] = it + 2;

                    f++;
                }

                meshes[i] = new Mesh();
                meshes[i].vertices = v;
                meshes[i].normals = n;
                meshes[i].triangles = t;

            }

            return meshes;
        }

    }
}

另一种解决方案可能是dynamically combine vertices that share the same space。当您在运行时引入模型时，您可以组合彼此在某个阈值内的顶点，以将顶点总数减少到65k限制以下。

或者，使用工具(如Mesh Simplify )降低细节级别，使您可以优化性能并将多边形数减少到65k以下，以便在不超过65k限制的情况下导入网格。有不同的，更实惠的选择，但这似乎是一个更好的可用的。