rabidus-test/Assets/PolyFew/ThirdParty/Whinarn_UnityMeshSimplifier/Runtime/MeshSimplifier.cs

#region License
/*
MIT License

Copyright(c) 2017 Mattias Edlund

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#endregion

#region Original License
/////////////////////////////////////////////
//
// Mesh Simplification Tutorial
//
// (C) by Sven Forstmann in 2014
//
// License : MIT
// http://opensource.org/licenses/MIT
//
//https://github.com/sp4cerat/Fast-Quadric-Mesh-Simplification
#endregion

#if UNITY_2018_2_OR_NEWER
#define UNITY_8UV_SUPPORT
#endif

#if UNITY_2017_3_OR_NEWER
#define UNITY_MESH_INDEXFORMAT_SUPPORT
#endif

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using UnityEngine;


namespace UnityMeshSimplifier
{
    /// <summary>
    /// The mesh simplifier.
    /// Deeply based on https://github.com/sp4cerat/Fast-Quadric-Mesh-Simplification but rewritten completely in C#.
    /// </summary>
    public sealed class MeshSimplifier
    {
        #region Consts & Static Read-Only
        private const int TriangleEdgeCount = 3;
        private const int TriangleVertexCount = 3;
        private const int EdgeVertexCount = 2;
        private const double DoubleEpsilon = 1.0E-3;
        private static readonly int UVChannelCount = MeshUtils.UVChannelCount;
        #endregion

        #region Fields
        private bool verbose = false;
        private int subMeshCount = 0;
        private int[] subMeshOffsets = null;
        private ResizableArray<Triangle> triangles = null;
        private ResizableArray<Vertex> vertices = null;
        private ResizableArray<Ref> vtx2tris = null;
        private ResizableArray<Edge> vtx2edges = null;

        // Edge based algorithm
        private List<Edge> edgesL = null;
        private ResizableArray<Edge> edgesRA = null;
        private const double PenaltyWeightBorder = 2E1;
        private const double PenaltyWeightUVSeamOrFoldover = 1E1;
        private const double DegeneratedTriangleCriteria = 0.9999999999; // if (Vector3d.Dot(e1, e2) > DegeneratedTriangleCriteria) --> triangle is degenerated
        private const double FlippedTriangleCriteria = 0.0; // if (Vector3d.Dot(ref n, ref t.n) < FlippedTriangleCriteria) --> triangle will flip
        private const double RecycleRejectedEdgesThreshold = 0.0025;

        private ResizableArray<Vector3> vertNormals = null;
        private ResizableArray<Vector4> vertTangents = null;
        private UVChannels<Vector2> vertUV2D = null;
        private UVChannels<Vector3> vertUV3D = null;
        private UVChannels<Vector4> vertUV4D = null;
        private ResizableArray<Color> vertColors = null;
        private ResizableArray<BoneWeight> vertBoneWeights = null;
        private ResizableArray<BlendShapeContainer> blendShapes = null;

        private Matrix4x4[] bindposes = null;

        // Pre-allocated buffers
        private readonly double[] errArr = new double[3];
        private readonly int[] attributeIndexArr = new int[3];
        private readonly HashSet<Triangle> triangleHashSet1 = new HashSet<Triangle>();
        private readonly HashSet<Triangle> triangleHashSet2 = new HashSet<Triangle>();



        public bool isSkinned;
        public BoneWeight[] boneWeightsOriginal;
        public Matrix4x4[] bindPosesOriginal;
        public Transform[] bonesOriginal;
        public Mesh meshToSimplify;

        public ToleranceSphere[] toleranceSpheres;
        private Dictionary<int, Matrix4x4> transformations = new Dictionary<int, Matrix4x4>();
        private HashSet<object> trianglesInToleranceSpheres = new HashSet<object>();

        private bool isPreservationActive;
        private int once;

        private double vertexLinkDistanceSqr = double.Epsilon;
        private bool preserveBorderEdges = false;
        private bool preserveUVSeamEdges = false;
        private bool preserveUVFoldoverEdges = false;
        private bool enableSmartLink = true;
        private bool recalculateNormals = false;
        private int maxIterationCount = 100;
        private double aggressiveness = 7.0;
        private bool regardCurvature = false;
        private bool useSortedEdgeMethod = false;
        private ToleranceSphere[] spheresToSubtract;

        #endregion

        #region Properties
        /// <summary>
        /// Gets or sets if the border edges should be preserved.
        /// Default value: false
        /// </summary>
        [Obsolete("Use the 'MeshSimplifier.PreserveBorderEdges' property instead.", false)]
        public bool PreserveBorders
        {
            get { return this.PreserveBorderEdges; }
            set { this.PreserveBorderEdges = value; }
        }

        /// <summary>
        /// Gets or sets if the border edges should be preserved.
        /// Default value: false
        /// </summary>
        public bool PreserveBorderEdges
        {
            get { return preserveBorderEdges; }
            set { preserveBorderEdges = value; }
        }

        /// <summary>
        /// Gets or sets if the UV seam edges should be preserved.
        /// Default value: false
        /// </summary>
        [Obsolete("Use the 'MeshSimplifier.PreserveUVSeamEdges' property instead.", false)]
        public bool PreserveSeams
        {
            get { return this.PreserveUVSeamEdges; }
            set { this.PreserveUVSeamEdges = value; }
        }

        /// <summary>
        /// Gets or sets if the UV seam edges should be preserved.
        /// Default value: false
        /// </summary>
        public bool PreserveUVSeamEdges
        {
            get { return preserveUVSeamEdges; }
            set { preserveUVSeamEdges = value; }
        }

        /// <summary>
        /// Gets or sets if the UV foldover edges should be preserved.
        /// Default value: false
        /// </summary>
        [Obsolete("Use the 'MeshSimplifier.PreserveUVFoldoverEdges' property instead.", false)]
        public bool PreserveFoldovers
        {
            get { return this.PreserveUVFoldoverEdges; }
            set { this.PreserveUVFoldoverEdges = value; }
        }

        /// <summary>
        /// Gets or sets if the UV foldover edges should be preserved.
        /// Default value: false
        /// </summary>
        public bool PreserveUVFoldoverEdges
        {
            get { return preserveUVFoldoverEdges; }
            set { preserveUVFoldoverEdges = value; }
        }

        /// <summary>
        /// Gets or sets if a feature for smarter vertex linking should be enabled, reducing artifacts in the
        /// decimated result at the cost of a slightly more expensive initialization by treating vertices at
        /// the same position as the same vertex while separating the attributes.
        /// Default value: true
        /// </summary>
        public bool EnableSmartLink
        {
            get { return enableSmartLink; }
            set { enableSmartLink = value; }
        }

        /// <summary>
        /// Recalculate mesh normals after simplification. Use this option if you see incorrect lighting or dark regions on the simplified mesh(es). This also recalculates the tangents afterwards.
        /// Default value: false
        /// </summary>
        public bool RecalculateNormals
        {
            get { return recalculateNormals; }
            set { recalculateNormals = value; }
        }

        /// <summary>
        /// Gets or sets the maximum iteration count. Higher number is more expensive but can bring you closer to your target quality.
        /// Sometimes a lower maximum count might be desired in order to lower the performance cost.
        /// Default value: 100
        /// </summary>
        public int MaxIterationCount
        {
            get { return maxIterationCount; }
            set { maxIterationCount = value; }
        }

        /// <summary>
        /// Gets or sets the agressiveness of the mesh simplification. Higher number equals higher quality, but more expensive to run.
        /// Default value: 7.0
        /// </summary>
        public double Aggressiveness
        {
            get { return aggressiveness; }
            set { aggressiveness = value; }
        }

        /// <summary>
        /// Gets or sets if discrete surface curvature shoudl be taken into account while simplification.
        /// Default value: false
        /// </summary>
        public bool RegardCurvature
        {
            get { return regardCurvature; }
            set { regardCurvature = value; }
        }

        /// <summary>
        /// Gets or sets if the sorted edges should be used for mesh simplification or not
        /// Default value: false
        /// </summary>
        public bool UseSortedEdgeMethod
        {
            get { return useSortedEdgeMethod; }
            set { useSortedEdgeMethod = value; }
        }
        
        /// <summary>
        /// Gets or sets if verbose information should be printed to the console.
        /// Default value: false
        /// </summary>
        public bool Verbose
        {
            get { return verbose; }
            set { verbose = value; }
        }


        /// <summary>
        /// Gets or sets the maximum distance between two vertices in order to link them.
        /// Note that this value is only used if EnableSmartLink is true.
        /// </summary>
        public double VertexLinkDistance
        {
            get { return Math.Sqrt(vertexLinkDistanceSqr); }
            set { vertexLinkDistanceSqr = (value > double.Epsilon ? value * value : double.Epsilon); }
        }

        /// <summary>
        /// Gets or sets the maximum squared distance between two vertices in order to link them.
        /// Note that this value is only used if EnableSmartLink is true.
        /// Default value: double.Epsilon
        /// </summary>
        public double VertexLinkDistanceSqr
        {
            get { return vertexLinkDistanceSqr; }
            set { vertexLinkDistanceSqr = value; }
        }

        /// <summary>
        /// Gets or sets the vertex positions.
        /// </summary>
        public Vector3[] Vertices
        {
            get
            {
                int vertexCount = this.vertices.Length;
                var vertices = new Vector3[vertexCount];
                var vertArr = this.vertices.Data;
                for (int i = 0; i < vertexCount; i++)
                {
                    vertices[i] = (Vector3)vertArr[i].p;
                }
                return vertices;
            }
            set
            {
                if (value == null)
                    throw new ArgumentNullException(nameof(value));

                bindposes = null;
                vertices.Resize(value.Length);
                var vertArr = vertices.Data;

                for (int i = 0; i < value.Length; i++)
                {
                    vertArr[i] = new Vertex(i, value[i]);

                    if (isPreservationActive && isSkinned && (i < boneWeightsOriginal.Length))
                    {

                        BoneWeight boneWeight = boneWeightsOriginal[i];
                        int key = bonesOriginal[boneWeight.boneIndex0].GetHashCode();

                        if (!transformations.ContainsKey(key))
                        {
                            transformations.Add(key, bonesOriginal[boneWeight.boneIndex0].localToWorldMatrix);
                        }

                        key = bonesOriginal[boneWeight.boneIndex1].GetHashCode();

                        if (!transformations.ContainsKey(key))
                        {
                            transformations.Add(key, bonesOriginal[boneWeight.boneIndex1].localToWorldMatrix);
                        }

                        key = bonesOriginal[boneWeight.boneIndex2].GetHashCode();

                        if (!transformations.ContainsKey(key))
                        {
                            transformations.Add(key, bonesOriginal[boneWeight.boneIndex2].localToWorldMatrix);
                        }

                        key = bonesOriginal[boneWeight.boneIndex3].GetHashCode();

                        if (!transformations.ContainsKey(key))
                        {
                            transformations.Add(key, bonesOriginal[boneWeight.boneIndex3].localToWorldMatrix);
                        }

                    }

                }
            }
        }

        /// <summary>
        /// Gets the count of sub-meshes.
        /// </summary>
        public int SubMeshCount
        {
            get { return subMeshCount; }
        }

        /// <summary>
        /// Gets the count of blend shapes.
        /// </summary>
        public int BlendShapeCount
        {
            get { return (blendShapes != null ? blendShapes.Length : 0); }
        }

        /// <summary>
        /// Gets or sets the vertex normals.
        /// </summary>
        public Vector3[] Normals
        {
            get { return (vertNormals != null ? vertNormals.Data : null); }
            set
            {
                InitializeVertexAttribute(value, ref vertNormals, "normals");
            }
        }

        /// <summary>
        /// Gets or sets the vertex tangents.
        /// </summary>
        public Vector4[] Tangents
        {
            get { return (vertTangents != null ? vertTangents.Data : null); }
            set
            {
                InitializeVertexAttribute(value, ref vertTangents, "tangents");
            }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 1.
        /// </summary>
        public Vector2[] UV1
        {
            get { return GetUVs2D(0); }
            set { SetUVs(0, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 2.
        /// </summary>
        public Vector2[] UV2
        {
            get { return GetUVs2D(1); }
            set { SetUVs(1, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 3.
        /// </summary>
        public Vector2[] UV3
        {
            get { return GetUVs2D(2); }
            set { SetUVs(2, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 4.
        /// </summary>
        public Vector2[] UV4
        {
            get { return GetUVs2D(3); }
            set { SetUVs(3, value); }
        }

#if UNITY_8UV_SUPPORT
        /// <summary>
        /// Gets or sets the vertex 2D UV set 5.
        /// </summary>
        public Vector2[] UV5
        {
            get { return GetUVs2D(4); }
            set { SetUVs(4, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 6.
        /// </summary>
        public Vector2[] UV6
        {
            get { return GetUVs2D(5); }
            set { SetUVs(5, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 7.
        /// </summary>
        public Vector2[] UV7
        {
            get { return GetUVs2D(6); }
            set { SetUVs(6, value); }
        }

        /// <summary>
        /// Gets or sets the vertex 2D UV set 8.
        /// </summary>
        public Vector2[] UV8
        {
            get { return GetUVs2D(7); }
            set { SetUVs(7, value); }
        }
#endif

        /// <summary>
        /// Gets or sets the vertex colors.
        /// </summary>
        public Color[] Colors
        {
            get { return (vertColors != null ? vertColors.Data : null); }
            set
            {
                InitializeVertexAttribute(value, ref vertColors, "colors");
            }
        }

        /// <summary>
        /// Gets or sets the vertex bone weights.
        /// </summary>
        public BoneWeight[] BoneWeights
        {
            get { return (vertBoneWeights != null ? vertBoneWeights.Data : null); }
            set
            {
                InitializeVertexAttribute(value, ref vertBoneWeights, "boneWeights");
            }
        }
        #endregion

        #region Constructors
        /// <summary>
        /// Creates a new mesh simplifier.
        /// </summary>
        public MeshSimplifier()
        {
            triangles = new ResizableArray<Triangle>(0);
            vertices = new ResizableArray<Vertex>(0);
            vtx2tris = new ResizableArray<Ref>(0);
        }

        /// <summary>
        /// Creates a new mesh simplifier.
        /// </summary>
        /// <param name="mesh">The original mesh to simplify.</param>
        public MeshSimplifier(Mesh mesh)
            : this()
        {
            if (mesh != null)
            {
                Initialize(mesh);
            }
        }
        #endregion

        #region Private Methods
        #region Initialize Vertex Attribute
        private void InitializeVertexAttribute<T>(T[] attributeValues, ref ResizableArray<T> attributeArray, string attributeName)
        {
            if (attributeValues != null && attributeValues.Length == vertices.Length)
            {
                if (attributeArray == null)
                {
                    attributeArray = new ResizableArray<T>(attributeValues.Length, attributeValues.Length);
                }
                else
                {
                    attributeArray.Resize(attributeValues.Length);
                }

                var arrayData = attributeArray.Data;
                Array.Copy(attributeValues, 0, arrayData, 0, attributeValues.Length);
            }
            else
            {
                if (attributeValues != null && attributeValues.Length > 0)
                {
                    Debug.LogErrorFormat("Failed to set vertex attribute '{0}' with {1} length of array, when {2} was needed.", attributeName, attributeValues.Length, vertices.Length);
                }
                attributeArray = null;
            }
        }
        #endregion

        #region Calculate Error
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static double VertexError(SymmetricMatrix q, double x, double y, double z)
        {
            return q.m0 * x * x + 2 * q.m1 * x * y + 2 * q.m2 * x * z + 2 * q.m3 * x + q.m4 * y * y
                + 2 * q.m5 * y * z + 2 * q.m6 * y + q.m7 * z * z + 2 * q.m8 * z + q.m9;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private double CurvatureError(ref Vertex vert0, ref Vertex vert1)
        {
            double diffVector = (vert0.p - vert1.p).Magnitude;

            var trianglesWithViOrVjOrBoth = triangleHashSet1;
            trianglesWithViOrVjOrBoth.Clear();
            GetTrianglesContainingVertex(ref vert0, trianglesWithViOrVjOrBoth);
            GetTrianglesContainingVertex(ref vert1, trianglesWithViOrVjOrBoth);

            var trianglesWithViAndVjBoth = triangleHashSet2;
            trianglesWithViAndVjBoth.Clear();
            GetTrianglesContainingBothVertices(ref vert0, ref vert1, trianglesWithViAndVjBoth);

            double maxDotOuter = 0;
            foreach (var triangleWithViOrVjOrBoth in trianglesWithViOrVjOrBoth)
            {
                double maxDotInner = 0;
                Vector3d normVecTriangleWithViOrVjOrBoth = triangleWithViOrVjOrBoth.n;

                foreach (var triangleWithViAndVjBoth in trianglesWithViAndVjBoth)
                {
                    Vector3d normVecTriangleWithViAndVjBoth = triangleWithViAndVjBoth.n;
                    double dot = Vector3d.Dot(ref normVecTriangleWithViOrVjOrBoth, ref normVecTriangleWithViAndVjBoth);

                    if (dot > maxDotInner)
                        maxDotInner = dot;
                }

                if (maxDotInner > maxDotOuter)
                    maxDotOuter = maxDotInner;
            }

            return diffVector * maxDotOuter;
        }


        private double CalculateError(ref Vertex vert0, ref Vertex vert1, out Vector3d result)
        {
            // compute interpolated vertex
            SymmetricMatrix q = (vert0.q + vert1.q);
            bool borderEdge = (vert0.borderEdge && vert1.borderEdge);
            double error = 0.0;
            double det = q.Determinant1();
            if (det != 0.0 && !borderEdge)
            {
                // q_delta is invertible
                result = new Vector3d(
                    -1.0 / det * q.Determinant2(),  // vx = A41/det(q_delta)
                    1.0 / det * q.Determinant3(),   // vy = A42/det(q_delta)
                    -1.0 / det * q.Determinant4()); // vz = A43/det(q_delta)

                double curvatureError = 0;
                if (RegardCurvature)
                {
                    curvatureError = CurvatureError(ref vert0, ref vert1);
                }

                error = VertexError(q, result.x, result.y, result.z) + curvatureError;
            }
            else
            {
                // det = 0 -> try to find best result
                Vector3d p1 = vert0.p;
                Vector3d p2 = vert1.p;
                Vector3d p3 = (p1 + p2) * 0.5f;
                double error1 = VertexError(q, p1.x, p1.y, p1.z);
                double error2 = VertexError(q, p2.x, p2.y, p2.z);
                double error3 = VertexError(q, p3.x, p3.y, p3.z);

                if (error1 < error2)
                {
                    if (error1 < error3)
                    {
                        error = error1;
                        result = p1;
                    }
                    else
                    {
                        error = error3;
                        result = p3;
                    }
                }
                else if (error2 < error3)
                {
                    error = error2;
                    result = p2;
                }
                else
                {
                    error = error3;
                    result = p3;
                }
            }
            return error;
        }
        #endregion

        #region Calculate Barycentric Coordinates
        private static void CalculateBarycentricCoords(ref Vector3d point, ref Vector3d a, ref Vector3d b, ref Vector3d c, out Vector3 result)
        {
            Vector3 v0 = (Vector3)(b - a), v1 = (Vector3)(c - a), v2 = (Vector3)(point - a);
            float d00 = Vector3.Dot(v0, v0);
            float d01 = Vector3.Dot(v0, v1);
            float d11 = Vector3.Dot(v1, v1);
            float d20 = Vector3.Dot(v2, v0);
            float d21 = Vector3.Dot(v2, v1);
            float denom = d00 * d11 - d01 * d01;
            float v = (d11 * d20 - d01 * d21) / denom;
            float w = (d00 * d21 - d01 * d20) / denom;
            float u = 1f - v - w;

            result = new Vector3(u, v, w);
        }
        #endregion

        #region Normalize Tangent
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static Vector4 NormalizeTangent(Vector4 tangent)
        {
            var tangentVec = new Vector3(tangent.x, tangent.y, tangent.z);
            tangentVec.Normalize();
            return new Vector4(tangentVec.x, tangentVec.y, tangentVec.z, tangent.w);
        }
        #endregion

        #region Flipped
        /// <summary>
        /// Check if a triangle flips when this edge is removed
        /// </summary>
        private bool Flipped(ref Vector3d p, int i0, int i1, ref Vertex v0, bool[] deleted)
        {
            int tcount = v0.tcount;
            var refs = this.vtx2tris.Data;
            var triangles = this.triangles.Data;
            var vertices = this.vertices.Data;
            for (int k = 0; k < tcount; k++)
            {
                Ref r = refs[v0.tstart + k];
                if (triangles[r.tid].deleted)
                    continue;

                int s = r.tvertex;
                int id1 = triangles[r.tid][(s + 1) % 3];
                int id2 = triangles[r.tid][(s + 2) % 3];
                if (id1 == i1 || id2 == i1)
                {
                    deleted[k] = true;
                    continue;
                }

                Vector3d d1 = vertices[id1].p - p;
                d1.Normalize();
                Vector3d d2 = vertices[id2].p - p;
                d2.Normalize();
                double dot = Vector3d.Dot(ref d1, ref d2);
                if (Math.Abs(dot) > 0.999)
                    return true;

                Vector3d n;
                Vector3d.Cross(ref d1, ref d2, out n);
                n.Normalize();
                deleted[k] = false;
                dot = Vector3d.Dot(ref n, ref triangles[r.tid].n);
                if (dot < 0.2)
                    return true;
            }

            return false;
        }
        #endregion

        #region Update Triangles
        /// <summary>
        /// Update triangle connections and edge error after a edge is collapsed.
        /// </summary>
        private void UpdateTriangles(int i0, int ia0, ref Vertex v, ResizableArray<bool> deleted, ref int deletedTriangles)
        {
            Vector3d p;
            int tcount = v.tcount;
            var triangles = this.triangles.Data;
            var vertices = this.vertices.Data;
            for (int k = 0; k < tcount; k++)
            {
                Ref r = vtx2tris[v.tstart + k];
                int tid = r.tid;
                Triangle t = triangles[tid];
                if (t.deleted)
                    continue;

                if (deleted[k])
                {
                    triangles[tid].deleted = true;
                    ++deletedTriangles;
                    continue;
                }

                t[r.tvertex] = i0;
                if (ia0 != -1)
                {
                    t.SetAttributeIndex(r.tvertex, ia0);
                }

                t.dirty = true;
                t.err0 = CalculateError(ref vertices[t.v0], ref vertices[t.v1], out p);
                t.err1 = CalculateError(ref vertices[t.v1], ref vertices[t.v2], out p);
                t.err2 = CalculateError(ref vertices[t.v2], ref vertices[t.v0], out p);
                t.err3 = MathHelper.Min(t.err0, t.err1, t.err2);
                triangles[tid] = t;
                vtx2tris.Add(r);
            }
        }
        #endregion

        #region Interpolate Vertex Attributes
        private void InterpolateVertexAttributes(int dst, int i0, int i1, int i2, ref Vector3 barycentricCoord)
        {
            if (vertNormals != null)
            {
                vertNormals[dst] = Vector3.Normalize((vertNormals[i0] * barycentricCoord.x) + (vertNormals[i1] * barycentricCoord.y) + (vertNormals[i2] * barycentricCoord.z));
            }
            if (vertTangents != null)
            {
                vertTangents[dst] = NormalizeTangent((vertTangents[i0] * barycentricCoord.x) + (vertTangents[i1] * barycentricCoord.y) + (vertTangents[i2] * barycentricCoord.z));
            }
            if (vertUV2D != null)
            {
                for (int i = 0; i < UVChannelCount; i++)
                {
                    var vertUV = vertUV2D[i];
                    if (vertUV != null)
                    {
                        vertUV[dst] = (vertUV[i0] * barycentricCoord.x) + (vertUV[i1] * barycentricCoord.y) + (vertUV[i2] * barycentricCoord.z);
                    }
                }
            }
            if (vertUV3D != null)
            {
                for (int i = 0; i < UVChannelCount; i++)
                {
                    var vertUV = vertUV3D[i];
                    if (vertUV != null)
                    {
                        vertUV[dst] = (vertUV[i0] * barycentricCoord.x) + (vertUV[i1] * barycentricCoord.y) + (vertUV[i2] * barycentricCoord.z);
                    }
                }
            }
            if (vertUV4D != null)
            {
                for (int i = 0; i < UVChannelCount; i++)
                {
                    var vertUV = vertUV4D[i];
                    if (vertUV != null)
                    {
                        vertUV[dst] = (vertUV[i0] * barycentricCoord.x) + (vertUV[i1] * barycentricCoord.y) + (vertUV[i2] * barycentricCoord.z);
                    }
                }
            }
            if (vertColors != null)
            {
                vertColors[dst] = (vertColors[i0] * barycentricCoord.x) + (vertColors[i1] * barycentricCoord.y) + (vertColors[i2] * barycentricCoord.z);
            }
            if (blendShapes != null)
            {
                for (int i = 0; i < blendShapes.Length; i++)
                {
                    blendShapes[i].InterpolateVertexAttributes(dst, i0, i1, i2, ref barycentricCoord);
                }
            }

            // TODO: How do we interpolate the bone weights? Do we have to?
        }
        #endregion

        #region Are UVs The Same
        private bool AreUVsTheSame(int channel, int indexA, int indexB)
        {
            if (vertUV2D != null)
            {
                var vertUV = vertUV2D[channel];
                if (vertUV != null)
                {
                    var uvA = vertUV[indexA];
                    var uvB = vertUV[indexB];
                    return uvA == uvB;
                }
            }

            if (vertUV3D != null)
            {
                var vertUV = vertUV3D[channel];
                if (vertUV != null)
                {
                    var uvA = vertUV[indexA];
                    var uvB = vertUV[indexB];
                    return uvA == uvB;
                }
            }

            if (vertUV4D != null)
            {
                var vertUV = vertUV4D[channel];
                if (vertUV != null)
                {
                    var uvA = vertUV[indexA];
                    var uvB = vertUV[indexB];
                    return uvA == uvB;
                }
            }

            return false;
        }
        #endregion

        #region Remove Vertex Pass
        /// <summary>
        /// Remove vertices and mark deleted triangles
        /// </summary>
        private void RemoveVertexPass(int startTrisCount, int targetTrisCount, double threshold, ResizableArray<bool> deleted0, ResizableArray<bool> deleted1, ref int deletedTris, bool isPreservationActive = false)
        {
            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            var vertices = this.vertices.Data;

            Vector3d p;
            Vector3 barycentricCoord;
            var preserveBorderEdges = PreserveBorderEdges;
            var preserveUVSeamEdges = PreserveUVSeamEdges;
            var preserveUVFoldoverEdges = PreserveUVFoldoverEdges;

            for (int tid = 0; tid < triangleCount; tid++)
            {

                Triangle triangle = triangles[tid];

                if (isPreservationActive && TriangleLiesInSphere(triangle))
                {
                    continue;
                }

                if (triangles[tid].dirty || triangles[tid].deleted || triangles[tid].err3 > threshold)
                    continue;

                triangles[tid].GetErrors(errArr);
                triangles[tid].GetAttributeIndices(attributeIndexArr);
                for (int edgeIndex = 0; edgeIndex < TriangleEdgeCount; edgeIndex++)
                {
                    if (errArr[edgeIndex] > threshold)
                        continue;

                    int nextEdgeIndex = ((edgeIndex + 1) % TriangleEdgeCount);
                    int i0 = triangles[tid][edgeIndex];
                    int i1 = triangles[tid][nextEdgeIndex];

                    // Border check
                    if (vertices[i0].borderEdge != vertices[i1].borderEdge)
                        continue;
                    // Seam check
                    else if (vertices[i0].uvSeamEdge != vertices[i1].uvSeamEdge)
                        continue;
                    // Foldover check
                    else if (vertices[i0].uvFoldoverEdge != vertices[i1].uvFoldoverEdge)
                        continue;
                    // If borders should be preserved
                    else if (preserveBorderEdges && vertices[i0].borderEdge)
                        continue;
                    // If seams should be preserved
                    else if (preserveUVSeamEdges && vertices[i0].uvSeamEdge)
                        continue;
                    // If foldovers should be preserved
                    else if (preserveUVFoldoverEdges && vertices[i0].uvFoldoverEdge)
                        continue;

                    // Compute vertex to collapse to
                    CalculateError(ref vertices[i0], ref vertices[i1], out p);
                    deleted0.Resize(vertices[i0].tcount); // normals temporarily
                    deleted1.Resize(vertices[i1].tcount); // normals temporarily

                    // Don't remove if flipped
                    if (Flipped(ref p, i0, i1, ref vertices[i0], deleted0.Data))
                        continue;
                    if (Flipped(ref p, i1, i0, ref vertices[i1], deleted1.Data))
                        continue;

                    // Calculate the barycentric coordinates within the triangle
                    int nextNextEdgeIndex = ((edgeIndex + 2) % 3);
                    int i2 = triangles[tid][nextNextEdgeIndex];
                    CalculateBarycentricCoords(ref p, ref vertices[i0].p, ref vertices[i1].p, ref vertices[i2].p, out barycentricCoord);

                    // Not flipped, so remove edge
                    vertices[i0].p = p;
                    vertices[i0].q += vertices[i1].q;
                    var v = vertices[i0];
                    
                    if (isPreservationActive)
                    {
                        if (spheresToSubtract != null)
                        {
                            foreach (var sphere in spheresToSubtract)
                            {
                                if (sphere != null) { sphere.currentEnclosedTrianglesCount--; }
                            }
                        }
                        
                        spheresToSubtract = null;
                    }



                    // Interpolate the vertex attributes
                    int ia0 = attributeIndexArr[edgeIndex];
                    int ia1 = attributeIndexArr[nextEdgeIndex];
                    int ia2 = attributeIndexArr[nextNextEdgeIndex];
                    InterpolateVertexAttributes(ia0, ia0, ia1, ia2, ref barycentricCoord);

                    if (vertices[i0].uvSeamEdge)
                    {
                        ia0 = -1;
                    }

                    int tstart = vtx2tris.Length;
                    UpdateTriangles(i0, ia0, ref vertices[i0], deleted0, ref deletedTris);
                    UpdateTriangles(i0, ia0, ref vertices[i1], deleted1, ref deletedTris);

                    int tcount = vtx2tris.Length - tstart;
                    if (tcount <= vertices[i0].tcount)
                    {
                        // save ram
                        if (tcount > 0)
                        {
                            var refsArr = vtx2tris.Data;
                            Array.Copy(refsArr, tstart, refsArr, vertices[i0].tstart, tcount);
                        }
                    }
                    else
                    {
                        // append
                        vertices[i0].tstart = tstart;
                    }

                    vertices[i0].tcount = tcount;
                    break;
                }

                // Check if we are already done
                if ((startTrisCount - deletedTris) <= targetTrisCount)
                    break;
            }
        }
        #endregion

        #region Update Mesh
        /// <summary>
        /// Compact triangles, compute edge error and build reference list.
        /// </summary>
        /// <param name="iteration">The iteration index.</param>
        private void UpdateMesh(int iteration)
        {
            var triangles = this.triangles.Data;
            var vertices = this.vertices.Data;

            int triangleCount = this.triangles.Length;
            int vertexCount = this.vertices.Length;
            if (iteration > 0) // compact triangles
            {
                int dst = 0;
                for (int i = 0; i < triangleCount; i++)
                {
                    if (!triangles[i].deleted)
                    {
                        if (dst != i)
                        {
                            triangles[dst] = triangles[i];
                            triangles[dst].index = dst;
                        }
                        dst++;
                    }
                }
                this.triangles.Resize(dst);
                triangles = this.triangles.Data;
                triangleCount = dst;
            }

            UpdateReferences();

            // Identify boundary : vertices[].border=0,1
            if (iteration == 0)
            {
                var refs = this.vtx2tris.Data;

                var vcount = new List<int>(8);
                var vids = new List<int>(8);
                int vsize = 0;
                for (int i = 0; i < vertexCount; i++)
                {
                    vertices[i].borderEdge = false;
                    vertices[i].uvSeamEdge = false;
                    vertices[i].uvFoldoverEdge = false;
                }

                int ofs;
                int id;
                int borderVertexCount = 0;
                double borderMinX = double.MaxValue;
                double borderMaxX = double.MinValue;
                double vertexLinkDistanceSqr = VertexLinkDistance * VertexLinkDistance;
                for (int i = 0; i < vertexCount; i++)
                {
                    int tstart = vertices[i].tstart;
                    int tcount = vertices[i].tcount;
                    vcount.Clear();
                    vids.Clear();
                    vsize = 0;

                    for (int j = 0; j < tcount; j++)
                    {
                        int tid = refs[tstart + j].tid;
                        for (int k = 0; k < TriangleVertexCount; k++)
                        {
                            ofs = 0;
                            id = triangles[tid][k];
                            while (ofs < vsize)
                            {
                                if (vids[ofs] == id)
                                    break;

                                ++ofs;
                            }

                            if (ofs == vsize)
                            {
                                vcount.Add(1);
                                vids.Add(id);
                                ++vsize;
                            }
                            else
                            {
                                ++vcount[ofs];
                            }
                        }
                    }

                    for (int j = 0; j < vsize; j++)
                    {
                        if (vcount[j] == 1)
                        {
                            id = vids[j];
                            vertices[id].borderEdge = true;
                            ++borderVertexCount;

                            if (EnableSmartLink)
                            {
                                if (vertices[id].p.x < borderMinX)
                                {
                                    borderMinX = vertices[id].p.x;
                                }
                                if (vertices[id].p.x > borderMaxX)
                                {
                                    borderMaxX = vertices[id].p.x;
                                }
                            }
                        }
                    }
                }

                if (EnableSmartLink)
                {
                    // First find all border vertices
                    var borderVertices = new BorderVertex[borderVertexCount];
                    int borderIndexCount = 0;
                    double borderAreaWidth = borderMaxX - borderMinX;
                    for (int i = 0; i < vertexCount; i++)
                    {
                        if (vertices[i].borderEdge)
                        {
                            int vertexHash = (int)(((((vertices[i].p.x - borderMinX) / borderAreaWidth) * 2.0) - 1.0) * int.MaxValue);
                            borderVertices[borderIndexCount] = new BorderVertex(i, vertexHash);
                            ++borderIndexCount;
                        }
                    }

                    // Sort the border vertices by hash
                    Array.Sort(borderVertices, 0, borderIndexCount, BorderVertexComparer.instance);

                    // Calculate the maximum hash distance based on the maximum vertex link distance
                    double vertexLinkDistance = VertexLinkDistance;
                    int hashMaxDistance = Math.Max((int)((vertexLinkDistance / borderAreaWidth) * int.MaxValue), 1);

                    // Then find identical border vertices and bind them together as one
                    for (int i = 0; i < borderIndexCount; i++)
                    {
                        int myIndex = borderVertices[i].index;
                        if (myIndex == -1)
                            continue;

                        var myPoint = vertices[myIndex].p;
                        for (int j = i + 1; j < borderIndexCount; j++)
                        {
                            int otherIndex = borderVertices[j].index;
                            if (otherIndex == -1)
                                continue;
                            else if ((borderVertices[j].hash - borderVertices[i].hash) > hashMaxDistance) // There is no point to continue beyond this point
                                break;

                            var otherPoint = vertices[otherIndex].p;
                            var sqrX = ((myPoint.x - otherPoint.x) * (myPoint.x - otherPoint.x));
                            var sqrY = ((myPoint.y - otherPoint.y) * (myPoint.y - otherPoint.y));
                            var sqrZ = ((myPoint.z - otherPoint.z) * (myPoint.z - otherPoint.z));
                            var sqrMagnitude = sqrX + sqrY + sqrZ;

                            if (sqrMagnitude <= vertexLinkDistanceSqr)
                            {
                                borderVertices[j].index = -1; // NOTE: This makes sure that the "other" vertex is not processed again
                                vertices[myIndex].borderEdge = false;
                                vertices[otherIndex].borderEdge = false;

                                if (AreUVsTheSame(0, myIndex, otherIndex))
                                {
                                    vertices[myIndex].uvFoldoverEdge = true;
                                    vertices[otherIndex].uvFoldoverEdge = true;
                                }
                                else
                                {
                                    vertices[myIndex].uvSeamEdge = true;
                                    vertices[otherIndex].uvSeamEdge = true;
                                }

                                int otherTriangleCount = vertices[otherIndex].tcount;
                                int otherTriangleStart = vertices[otherIndex].tstart;
                                for (int k = 0; k < otherTriangleCount; k++)
                                {
                                    var r = refs[otherTriangleStart + k];
                                    triangles[r.tid][r.tvertex] = myIndex;
                                }
                            }
                        }
                    }

                    // Update the references again
                    UpdateReferences();
                }

                // Init Quadrics by Plane & Edge Errors
                //
                // required at the beginning ( iteration == 0 )
                // recomputing during the simplification is not required,
                // but mostly improves the result for closed meshes
                for (int i = 0; i < vertexCount; i++)
                {
                    vertices[i].q = new SymmetricMatrix(0);
                }

                int v0, v1, v2;
                Vector3d n, p0, p1, p2, p10, p20, dummy;
                SymmetricMatrix sm;
                for (int i = 0; i < triangleCount; i++)
                {
                    v0 = triangles[i].v0;
                    v1 = triangles[i].v1;
                    v2 = triangles[i].v2;

                    p0 = vertices[v0].p;
                    p1 = vertices[v1].p;
                    p2 = vertices[v2].p;
                    p10 = p1 - p0;
                    p20 = p2 - p0;
                    Vector3d.Cross(ref p10, ref p20, out n);
                    n.Normalize();
                    triangles[i].n = n;

                    sm = new SymmetricMatrix(n, p0);
                    vertices[v0].q.Add(sm);
                    vertices[v1].q.Add(sm);
                    vertices[v2].q.Add(sm);
                }

                // save execution time
                if (UseSortedEdgeMethod)
                {
                    for (int i = 0; i < triangleCount; i++)
                    {
                        // Calc Edge Error
                        var triangle = triangles[i];
                        triangles[i].err0 = CalculateError(ref vertices[triangle.v0], ref vertices[triangle.v1], out dummy);
                        triangles[i].err1 = CalculateError(ref vertices[triangle.v1], ref vertices[triangle.v2], out dummy);
                        triangles[i].err2 = CalculateError(ref vertices[triangle.v2], ref vertices[triangle.v0], out dummy);
                        triangles[i].err3 = MathHelper.Min(triangles[i].err0, triangles[i].err1, triangles[i].err2);
                    }
                }
            }
        }
        #endregion

        #region Update References
        private void UpdateReferences()
        {
            int triangleCount = this.triangles.Length;
            int vertexCount = this.vertices.Length;
            var triangles = this.triangles.Data;
            var vertices = this.vertices.Data;

            // Init Reference ID list
            for (int i = 0; i < vertexCount; i++)
            {
                vertices[i].tstart = 0;
                vertices[i].tcount = 0;
            }

            for (int i = 0; i < triangleCount; i++)
            {
                ++vertices[triangles[i].v0].tcount;
                ++vertices[triangles[i].v1].tcount;
                ++vertices[triangles[i].v2].tcount;
            }

            int tstart = 0;
            for (int i = 0; i < vertexCount; i++)
            {
                vertices[i].tstart = tstart;
                tstart += vertices[i].tcount;
                vertices[i].tcount = 0;
            }

            // Write References
            this.vtx2tris.Resize(tstart);
            var refs = this.vtx2tris.Data;
            Ref r;
            for (int i = 0; i < triangleCount; i++)
            {
                int v0 = triangles[i].v0;
                int v1 = triangles[i].v1;
                int v2 = triangles[i].v2;
                int start0 = vertices[v0].tstart;
                int count0 = vertices[v0].tcount++;
                int start1 = vertices[v1].tstart;
                int count1 = vertices[v1].tcount++;
                int start2 = vertices[v2].tstart;
                int count2 = vertices[v2].tcount++;

                r = new Ref();
                r.Set(i, 0);
                refs[start0 + count0] = r;
                r = new Ref();
                r.Set(i, 1);
                refs[start1 + count1] = r;
                r = new Ref();
                r.Set(i, 2);
                refs[start2 + count2] = r;

            }
        }
        #endregion

        #region Compact Mesh
        /// <summary>
        /// Finally compact mesh before exiting.
        /// </summary>
        private void CompactMesh()
        {
            int dst = 0;
            var vertices = this.vertices.Data;
            int vertexCount = this.vertices.Length;
            for (int i = 0; i < vertexCount; i++)
            {
                vertices[i].tcount = 0;
            }

            var vertNormals = (this.vertNormals != null ? this.vertNormals.Data : null);
            var vertTangents = (this.vertTangents != null ? this.vertTangents.Data : null);
            var vertUV2D = (this.vertUV2D != null ? this.vertUV2D.Data : null);
            var vertUV3D = (this.vertUV3D != null ? this.vertUV3D.Data : null);
            var vertUV4D = (this.vertUV4D != null ? this.vertUV4D.Data : null);
            var vertColors = (this.vertColors != null ? this.vertColors.Data : null);
            var vertBoneWeights = (this.vertBoneWeights != null ? this.vertBoneWeights.Data : null);
            var blendShapes = (this.blendShapes != null ? this.blendShapes.Data : null);

            int lastSubMeshIndex = -1;
            subMeshOffsets = new int[subMeshCount];

            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            for (int i = 0; i < triangleCount; i++)
            {
                var triangle = triangles[i];
                if (!triangle.deleted)
                {
                    if (triangle.va0 != triangle.v0)
                    {
                        int iDest = triangle.va0;
                        int iSrc = triangle.v0;
                        vertices[iDest].p = vertices[iSrc].p;
                        if (vertBoneWeights != null)
                        {
                            vertBoneWeights[iDest] = vertBoneWeights[iSrc];
                        }
                        triangle.v0 = triangle.va0;
                    }
                    if (triangle.va1 != triangle.v1)
                    {
                        int iDest = triangle.va1;
                        int iSrc = triangle.v1;
                        vertices[iDest].p = vertices[iSrc].p;
                        if (vertBoneWeights != null)
                        {
                            vertBoneWeights[iDest] = vertBoneWeights[iSrc];
                        }
                        triangle.v1 = triangle.va1;
                    }
                    if (triangle.va2 != triangle.v2)
                    {
                        int iDest = triangle.va2;
                        int iSrc = triangle.v2;
                        vertices[iDest].p = vertices[iSrc].p;
                        if (vertBoneWeights != null)
                        {
                            vertBoneWeights[iDest] = vertBoneWeights[iSrc];
                        }
                        triangle.v2 = triangle.va2;
                    }
                    int newTriangleIndex = dst++;
                    triangles[newTriangleIndex] = triangle;
                    triangles[newTriangleIndex].index = newTriangleIndex;

                    vertices[triangle.v0].tcount = 1;
                    vertices[triangle.v1].tcount = 1;
                    vertices[triangle.v2].tcount = 1;

                    if (triangle.subMeshIndex > lastSubMeshIndex)
                    {
                        for (int j = lastSubMeshIndex + 1; j < triangle.subMeshIndex; j++)
                        {
                            subMeshOffsets[j] = newTriangleIndex;
                        }
                        subMeshOffsets[triangle.subMeshIndex] = newTriangleIndex;
                        lastSubMeshIndex = triangle.subMeshIndex;
                    }
                }
            }

            triangleCount = dst;
            for (int i = lastSubMeshIndex + 1; i < subMeshCount; i++)
            {
                subMeshOffsets[i] = triangleCount;
            }

            this.triangles.Resize(triangleCount);
            triangles = this.triangles.Data;

            dst = 0;
            for (int i = 0; i < vertexCount; i++)
            {
                var vert = vertices[i];
                if (vert.tcount > 0)
                {
                    vertices[i].tstart = dst;

                    if (dst != i)
                    {
                        vertices[dst].index = dst;
                        vertices[dst].p = vert.p;
                        if (vertNormals != null) vertNormals[dst] = vertNormals[i];
                        if (vertTangents != null) vertTangents[dst] = vertTangents[i];
                        if (vertUV2D != null)
                        {
                            for (int j = 0; j < UVChannelCount; j++)
                            {
                                var vertUV = vertUV2D[j];
                                if (vertUV != null)
                                {
                                    vertUV[dst] = vertUV[i];
                                }
                            }
                        }
                        if (vertUV3D != null)
                        {
                            for (int j = 0; j < UVChannelCount; j++)
                            {
                                var vertUV = vertUV3D[j];
                                if (vertUV != null)
                                {
                                    vertUV[dst] = vertUV[i];
                                }
                            }
                        }
                        if (vertUV4D != null)
                        {
                            for (int j = 0; j < UVChannelCount; j++)
                            {
                                var vertUV = vertUV4D[j];
                                if (vertUV != null)
                                {
                                    vertUV[dst] = vertUV[i];
                                }
                            }
                        }
                        if (vertColors != null) vertColors[dst] = vertColors[i];
                        if (vertBoneWeights != null) vertBoneWeights[dst] = vertBoneWeights[i];

                        if (blendShapes != null)
                        {
                            for (int shapeIndex = 0; shapeIndex < this.blendShapes.Length; shapeIndex++)
                            {
                                blendShapes[shapeIndex].MoveVertexElement(dst, i);
                            }
                        }
                    }
                    ++dst;
                }
            }

            for (int i = 0; i < triangleCount; i++)
            {
                var triangle = triangles[i];
                triangle.v0 = vertices[triangle.v0].tstart;
                triangle.v1 = vertices[triangle.v1].tstart;
                triangle.v2 = vertices[triangle.v2].tstart;
                triangles[i] = triangle;
            }

            vertexCount = dst;
            this.vertices.Resize(vertexCount);
            if (vertNormals != null) this.vertNormals.Resize(vertexCount, true);
            if (vertTangents != null) this.vertTangents.Resize(vertexCount, true);
            if (vertUV2D != null) this.vertUV2D.Resize(vertexCount, true);
            if (vertUV3D != null) this.vertUV3D.Resize(vertexCount, true);
            if (vertUV4D != null) this.vertUV4D.Resize(vertexCount, true);
            if (vertColors != null) this.vertColors.Resize(vertexCount, true);
            if (vertBoneWeights != null) this.vertBoneWeights.Resize(vertexCount, true);

            if (blendShapes != null)
            {
                for (int i = 0; i < this.blendShapes.Length; i++)
                {
                    blendShapes[i].Resize(vertexCount, false);
                }
            }
        }
        #endregion

        #region Calculate Sub Mesh Offsets
        private void CalculateSubMeshOffsets()
        {
            int lastSubMeshIndex = -1;
            subMeshOffsets = new int[subMeshCount];

            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            for (int i = 0; i < triangleCount; i++)
            {
                var triangle = triangles[i];
                if (triangle.subMeshIndex > lastSubMeshIndex)
                {
                    for (int j = lastSubMeshIndex + 1; j < triangle.subMeshIndex; j++)
                    {
                        subMeshOffsets[j] = i;
                    }
                    subMeshOffsets[triangle.subMeshIndex] = i;
                    lastSubMeshIndex = triangle.subMeshIndex;
                }
            }

            for (int i = lastSubMeshIndex + 1; i < subMeshCount; i++)
            {
                subMeshOffsets[i] = triangleCount;
            }
        }
        #endregion

        #region Triangle helper functions
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void GetTrianglesContainingVertex(ref Vertex vert, HashSet<Triangle> tris)
        {
            int trianglesCount = vert.tcount;
            int startIndex = vert.tstart;

            for (int a = startIndex; a < startIndex + trianglesCount; a++)
            {
                tris.Add(triangles[vtx2tris[a].tid]);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void GetTrianglesContainingBothVertices(ref Vertex vert0, ref Vertex vert1, HashSet<Triangle> tris)
        {
            int triangleCount = vert0.tcount;
            int startIndex = vert0.tstart;

            for (int refIndex = startIndex; refIndex < (startIndex + triangleCount); refIndex++)
            {
                int tid = vtx2tris[refIndex].tid;
                Triangle tri = triangles[tid];

                if (vertices[tri.v0].index == vert1.index ||
                    vertices[tri.v1].index == vert1.index ||
                    vertices[tri.v2].index == vert1.index)
                {
                    tris.Add(tri);
                }
            }
        }
        #endregion Triangle helper functions

        #region Sorted Edge Method

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void CalculateEdgeError(Edge edge)
        {
            const double nearZero = 1E-6;
            Vertex va = this.vertices.Data[edge.vertexA];
            Vertex vb = this.vertices.Data[edge.vertexB];
            SymmetricMatrix q = edge.q;

            q.Clear();
            q.Add(va.q);
            q.Add(vb.q);
            q.Subtract(edge.qTwice);
            if (PreserveBorderEdges || PreserveUVSeamEdges || PreserveUVFoldoverEdges)
            {
                q.Add(va.qPenaltyEdge);
                q.Add(vb.qPenaltyEdge);
            }

            edge.error = -1;
            if (q.ShapeIsGood())
            {
                // Gauss - Jordan Elimination method
                double P = q.m1 * q.m5 - q.m2 * q.m4;
                double Q = q.m1 * q.m7 - q.m2 * q.m5;
                double R = q.m1 * q.m8 - q.m2 * q.m6;
                double S = q.m0 * q.m4 - q.m1 * q.m1;
                double T = q.m0 * q.m5 - q.m1 * q.m2;
                double U = q.m0 * q.m6 - q.m1 * q.m3;
                double Zd = S * Q - P * T;

                if (((Zd > nearZero) || (Zd < -nearZero)) && ((S > nearZero) || (S < -nearZero)))
                {
                    double z = -(S * R - P * U) / Zd;
                    double y = -(U + T * z) / S; // back substitution for y
                    double x = -(q.m3 + q.m1 * y + q.m2 * z) / q.m0; // then x

                    edge.p = new Vector3d(x, y, z); // optimal solution
                    edge.error = Math.Abs(VertexError(q, edge.p.x, edge.p.y, edge.p.z));
                    //DebugMeshPerf.Data.nrErrorTypeEllipsoid++;
                }
            }

            if (edge.error == -1)
            {
                Vector3d p1 = va.p;
                Vector3d p2 = vb.p;
                Vector3d p3 = (va.p + vb.p) * 0.5;

                double error1 = Math.Abs(VertexError(q, p1.x, p1.y, p1.z));
                double error2 = Math.Abs(VertexError(q, p2.x, p2.y, p2.z));
                double error3 = Math.Abs(VertexError(q, p3.x, p3.y, p3.z));

                if (error1 < error2)
                {
                    if (error1 < error3)
                    {
                        edge.error = error1;
                        edge.p = p1;
                    }
                    else
                    {
                        edge.error = error3;
                        edge.p = p3;
                    }
                }
                else if (error2 < error3)
                {
                    edge.error = error2;
                    edge.p = p2;
                }
                else
                {
                    edge.error = error3;
                    edge.p = p3;
                }

                //DebugMeshPerf.Data.nrErrorTypeVertex++;

            }

            double curvatureError = 0;
            if (RegardCurvature)
            {
                Vertex vert0 = this.vertices[edge.vertexA];
                Vertex vert1 = this.vertices[edge.vertexB];
                curvatureError = CurvatureError(ref vert0, ref vert1);
            }

            edge.error += curvatureError;
        }

        /// <summary>
        /// Return true if this edge can be collapsed without causing problem
        /// Also update triangles normal and list of triangles passed as references 
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private bool ValidateContractionThenUpdateTrisNormals(Edge edge, ref int survivedIndex, ref int deletedIndex,
                                                ref List<Triangle> trisTouchingSurvivedVertexOnly,
                                                ref List<Triangle> trisTouchingDeletedVertexOnly,
                                                ref List<Triangle> trisTouchingBothVertices)
        {
            bool edgeContractionAccepted = true;

            trisTouchingSurvivedVertexOnly.Clear(); trisTouchingDeletedVertexOnly.Clear(); trisTouchingBothVertices.Clear();
            List<Triangle>[] trisTouchingThisVextexOnly = { trisTouchingSurvivedVertexOnly, trisTouchingDeletedVertexOnly };

            if (vertices[edge.vertexA].tcount > vertices[edge.vertexB].tcount)
            {
                survivedIndex = edge.vertexA;
                deletedIndex = edge.vertexB;
            }
            else
            {
                survivedIndex = edge.vertexB;
                deletedIndex = edge.vertexA;
            }
            int[] edgeVertex = { survivedIndex, deletedIndex };

            // extract triangles touching each vertex and update normals if edge can be contracted
            Triangle t;
            Vertex v;
            Ref r;

            for (int j = 0; j < EdgeVertexCount; j++)
            {
                int notj = j == 0 ? 1 : 0;
                v = vertices[edgeVertex[j]];
                for (int i = v.tstart; i < v.tstart + v.tcount; i++)
                {
                    r = vtx2tris[i];
                    t = triangles[r.tid];
                    if (!t.deleted)
                    {
                        //int v0 = edgeVertex[j]; // v0 is also equals to t[r.tvertex] and v.index;
                        int v1 = t[(r.tvertex + 1) % TriangleEdgeCount];
                        int v2 = t[(r.tvertex + 2) % TriangleEdgeCount];

                        // test if triangle touches both edge vertices
                        if (v1 == edgeVertex[notj] || v2 == edgeVertex[notj])
                        {
                            if (!trisTouchingBothVertices.Contains(t))
                                trisTouchingBothVertices.Add(t);
                            continue;
                        }
                        // test if triangle will flip after edge contraction
                        Vector3d d1 = vertices[v1].p - edge.p;
                        d1.Normalize();
                        Vector3d d2 = vertices[v2].p - edge.p;
                        d2.Normalize();
                        Vector3d n;
                        Vector3d.Cross(ref d1, ref d2, out n);
                        n.Normalize();
                        if (Vector3d.Dot(ref n, ref t.n) < FlippedTriangleCriteria)
                        {
                            edgeContractionAccepted = false;
                            return edgeContractionAccepted;
                        }

                        // update cache
                        if (Vector3d.Dot(ref d1, ref d2) > DegeneratedTriangleCriteria)
                        {
                            edgeContractionAccepted = false;
                            return edgeContractionAccepted;
                        }
                        else
                        {
                            t.nCached = n;
                        }
                        t.refCached = r;

                        trisTouchingThisVextexOnly[j].Add(t);
                    }
                }
            }

            // update normal of all triangles that have changed
            for (int j = 0; j < EdgeVertexCount; j++)
                foreach (var tt in trisTouchingThisVextexOnly[j])
                {
                    tt.n = tt.nCached;
                }

            return edgeContractionAccepted;
        }

        /// <summary>
        /// Calculate a penalty quadrics error matrix to preserve 2D border or uv seam/foldover.
        /// Edge e must be an edge of triangle t. Edge e is a 2D border, uv seam or uv foldover
        /// </summary>
        private void CalculateEdgePenaltyMatrix(Triangle t, Edge e)
        {
            e.qPenaltyBorderVertexA.Clear();
            e.qPenaltyBorderVertexB.Clear();
            Vector3d va = this.vertices[e.vertexA].p;
            Vector3d vb = this.vertices[e.vertexB].p;
            Vector3d edgeDir = (vb - va).Normalized;
            if (e.isBorder2D)
            {
                // add a plane perpendicular to triangle t and containing edge e.
                Vector3d penaltyPlaneNormal;
                Vector3d.Cross(ref t.n, ref edgeDir, out penaltyPlaneNormal);
                e.qPenaltyBorderVertexA.Add(ref penaltyPlaneNormal, ref va, 0.5 * PenaltyWeightBorder);
                e.qPenaltyBorderVertexB.Add(e.qPenaltyBorderVertexA);
            }
            if (e.isUVSeam || e.isUVFoldover)
            {
                e.qPenaltyBorderVertexA.Add(ref edgeDir, ref va, 0.5 * PenaltyWeightUVSeamOrFoldover);
                e.qPenaltyBorderVertexB.Add(ref edgeDir, ref vb, 0.5 * PenaltyWeightUVSeamOrFoldover);
            }
        }

        /// <summary>
        /// see CalculateEdgePenaltyMatrix()
        /// </summary>
        /// <param name="e"></param>
        /// <param name="v"></param>
        private void DistributeEdgePenaltyMatrix(Edge e, Vertex v)
        {
            if (v.index == e.vertexA)
                v.qPenaltyEdge.Add(e.qPenaltyBorderVertexA);
            else
                v.qPenaltyEdge.Add(e.qPenaltyBorderVertexB);
        }

        private void DistributeEdgePenaltyMatrix(Edge e)
        {
            vertices[e.vertexA].qPenaltyEdge.Add(e.qPenaltyBorderVertexA);
            vertices[e.vertexB].qPenaltyEdge.Add(e.qPenaltyBorderVertexB);
        }

        /// <summary>
        /// Create edge objects required to build a list of edges sorted by increasing quadric errors.
        /// All triangles and vertices must have been created and initialized before calling this procedure.
        /// The procedure will create an edge object for each edge of every triangle(without duplicating edges)
        /// Note that an edge from vertex Vi to Vj and an edge from vertex Vj to Vi
        /// are the same edge.
        /// </summary>
        /// <param name="degeneratedTriangles">degenerated triangles already count as deleted triangles</param>
        private void InitEdges(out int degeneratedTriangles)
        {
            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            var vertices = this.vertices.Data;
            int verticesCount = this.vertices.Length;
            degeneratedTriangles = 0;
            Triangle t, t1, t2;
            Vertex v, vxa, vxb;
            Edge e = null;
            this.edgesRA = new ResizableArray<Edge>(triangleCount * 3);
            var edges = this.edgesRA.Data;
            int[,] edgeBorder = new int[triangleCount * 3, 3];
            int edgeCount = 0;

            // create references between vertices and edges
            {
                // init edges count estimation
                int start = 0;
                for (int i = 0; i < verticesCount; i++)
                {
                    v = vertices[i];
                    v.estart = start;
                    v.ecount = 0;
                    start += v.tcount * 2;
                }
                vtx2edges = new ResizableArray<Edge>(start * 2, start); // will consume extra memory ...

                var v2t = this.vtx2tris.Data;
                var v2e = this.vtx2edges.Data;

                // create edges, init qTwice, init border
                for (int i = 0; i < triangleCount; i++)
                {
                    t = triangles[i];
                    if (t.deleted)
                        continue;
                    // skip degenerated triangle (it happens when using smart linking on cad from external apps)
                    if ((t.v0 == t.v1) || (t.v1 == t.v2) || (t.v2 == t.v0))
                    {
                        t.deleted = true;
                        degeneratedTriangles++;
                        continue;
                    }
                    
                    int va = t[0];
                    for (int j = 0; j < TriangleEdgeCount; j++)
                    {
                        // create or get this edge
                        int vb = t[(j + 1) % TriangleEdgeCount];
                        vxa = vertices[va];
                        vxb = vertices[vb];
                        ulong ekey = Edge.CalculateKey(va, vb);
                        bool edgeDoesNotExist = true;

                        for (int k = 0; k < vxa.ecount; k++)
                        {
                            if (v2e[vxa.estart + k].key == ekey)
                            {
                                edgeDoesNotExist = false;
                                e = v2e[vxa.estart + k];
                                break;
                            }
                        }

                        if (edgeDoesNotExist)
                        {
                            e = new Edge(va, vb);
                            e.index = edgeCount++;
                            edges[e.index] = e;
                            v2e[vxa.estart + vxa.ecount++] = e;
                            v2e[vxb.estart + vxb.ecount++] = e;
                        }
                        //
                        e.qTwice.Add(ref t.n, ref vxa.p);
                        // count tris for border detection
                        int trisCount = edgeBorder[e.index, 0];
                        edgeBorder[e.index, 0] = ++trisCount;
                        // No more than 2 triangles are required for the test
                        if (trisCount <= 2)
                            edgeBorder[e.index, trisCount] = t.index;

                        va = vb;
                    }

                    e.containingTriangle = t;
                }
            }
            this.edgesRA.Resize(edgeCount, true, false);
            edges = this.edgesRA.Data;

            // check to preserve edge
            for (int i = 0; i < edgeCount; i++)
            {
                e = edges[i];

                if (edgeBorder[i, 0] == 1) // only one triangle along this edge
                {
                    e.isBorder2D = true;
                    //DebugMeshPerf.Data.nrBorder2D++;
                }
                else if (edgeBorder[i, 0] == 2)
                {
                    t1 = triangles[edgeBorder[i, 1]];
                    t2 = triangles[edgeBorder[i, 2]];
                    if (Vector3d.Dot(ref t1.n, ref t2.n) < -0.9999) // double faced plane
                    {
                        e.isBorder2D = true;
                        //DebugMeshPerf.Data.nrBorder2D++;
                    }
                }

                if (vertices[e.vertexA].uvSeamEdge && vertices[e.vertexB].uvSeamEdge)
                {
                    e.isUVSeam = true;
                    //DebugMeshPerf.Data.nrUVSeamEdge++;
                }
                else if (vertices[e.vertexA].uvFoldoverEdge && vertices[e.vertexB].uvFoldoverEdge)
                {
                    e.isUVFoldover = true;
                    //DebugMeshPerf.Data.nrUVFoldoverEdge++;
                }
                if ((e.isBorder2D && PreserveBorderEdges) || (e.isUVSeam && PreserveUVSeamEdges) || (e.isUVFoldover && PreserveUVFoldoverEdges))
                {
                    t1 = triangles[edgeBorder[i, 1]];
                    CalculateEdgePenaltyMatrix(t1, e);
                    DistributeEdgePenaltyMatrix(e);
                }
            }

            // calculate edge error
            for (int i = 0; i < edgeCount; i++)
            {
                e = edges[i];
                CalculateEdgeError(e);
                e.errorKeyed = e.error;
            }

            // copy to sorted edges list
            this.edgesL = edges.OrderBy(ee => ee.errorKeyed).ToList();
        }

        /// <summary>
        /// Remove edges until enough triangles have been deleted
        /// </summary>
        private void RemoveEdgePass(int trisToDelete, ref int deletedTris)
        {
            var triangles = this.triangles.Data;
            var vertices = this.vertices.Data;
            var vtx2edges = this.vtx2edges.Data;
            var edgesL = this.edgesL;




            List<Edge> edgesLRejected = new List<Edge>();
            int recycleRejectedEdges = (int)(edgesL.Count * RecycleRejectedEdgesThreshold);

            List<Triangle> trisTouchingSurvivedVertexOnly = new List<Triangle>();
            List<Triangle> trisTouchingDeletedVertexOnly = new List<Triangle>();
            List<Triangle> trisTouchingBothVertices = new List<Triangle>();
            Dictionary<int, int> AttributeMapping = new Dictionary<int, int>();

            Edge edgeAssessed = null, edgeToMove = null, survivedEdge = null;
            Vertex survivedVertex, deletedVertex;
            Vector3 barycentricCoord = new Vector3();
            int survivedIndex = -1, deletedIndex = -1, thirdIndex = -1;
            int rankSurvivedIndex = -1, rankDeletedIndex = -1, rankThirdIndex = -1;

            int currentEdgeRank = 0;


            while ((trisToDelete > deletedTris) && (currentEdgeRank < edgesL.Count))
            {
                //DebugMeshPerf.Data.nrLoopTest++;

                int index = currentEdgeRank++;
                edgeAssessed = edgesL[index];

                // skip deleted edges
                if (edgeAssessed.isDeleted)
                    continue;

                // need re-sorting this edge
                if (edgeAssessed.error > edgeAssessed.errorKeyed)
                {
                    CalculateEdgeError(edgeAssessed);
                    //DebugMeshPerf.Data.nrErrorEval++; //
                    edgeAssessed.errorKeyed = edgeAssessed.error;
                    edgesL.AddSortedFromPosition(currentEdgeRank, edgeAssessed);
                    //DebugMeshPerf.Data.nrEdgeReinsert++;
                    continue;
                }




                else if (edgeAssessed.error < edgeAssessed.errorKeyed)
                {
                    //DebugMeshPerf.Data.nrEdgeLag++;
                }

                // retrieve all triangles touching this edge
                if (!ValidateContractionThenUpdateTrisNormals(edgeAssessed, ref survivedIndex, ref deletedIndex, ref trisTouchingSurvivedVertexOnly,
                        ref trisTouchingDeletedVertexOnly, ref trisTouchingBothVertices))
                {
                    edgesLRejected.Add(edgeAssessed);
                    //DebugMeshPerf.Data.nrEdgeRejected++;
                    continue;
                }


                // Will have to improve this
                if (isPreservationActive)
                {
                    bool ifContinue = false;

                    foreach(var triangle in trisTouchingDeletedVertexOnly)
                    {
                        if (TriangleLiesInSphere(triangle)) { ifContinue = true; }
                    }

                    foreach (var triangle in trisTouchingBothVertices)
                    {
                        if (TriangleLiesInSphere(triangle)) { ifContinue = true; }
                    }

                    if (spheresToSubtract != null)
                    {
                        foreach (var sphere in spheresToSubtract)
                        {
                            if (sphere != null) { sphere.currentEnclosedTrianglesCount--; }
                        }
                    }

                    spheresToSubtract = null;

                    if (ifContinue) { continue; }
                }


                survivedVertex = vertices[survivedIndex];
                deletedVertex = vertices[deletedIndex];

                // triangles to delete
                int deletedCount = 0;
                AttributeMapping.Clear();
                foreach (var t in trisTouchingBothVertices)
                {
                    // interpolate vertex attributes of new point p on the deleted edge

                    for (int i = 0; i <= TriangleEdgeCount; i++)
                    {
                        if (t[i] == survivedIndex)
                        {
                            rankSurvivedIndex = i;
                            rankDeletedIndex = (i + 1) % TriangleEdgeCount; // guess
                            if (t[rankDeletedIndex] != deletedIndex) // verify
                                rankDeletedIndex = (i + 2) % TriangleEdgeCount;
                            rankThirdIndex = TriangleEdgeCount - rankDeletedIndex - rankSurvivedIndex;
                            thirdIndex = t[rankThirdIndex];
                            break;
                        }
                    }

                    t.GetAttributeIndices(attributeIndexArr);
                    int ia0 = attributeIndexArr[rankSurvivedIndex];
                    int ia1 = attributeIndexArr[rankDeletedIndex];
                    int ia2 = attributeIndexArr[rankThirdIndex];

                    if (!AttributeMapping.ContainsValue(ia0))
                    {
                        CalculateBarycentricCoords(ref edgeAssessed.p, ref survivedVertex.p, ref deletedVertex.p, ref vertices[thirdIndex].p, out barycentricCoord);
                        InterpolateVertexAttributes(ia0, ia0, ia1, ia2, ref barycentricCoord);
                        AttributeMapping[ia1] = ia0;
                    }

                    t.deleted = true;
                    deletedCount++;
                }

                // attach tris to survided vertex
                foreach (var t in trisTouchingDeletedVertexOnly)
                {
                    rankDeletedIndex = t.refCached.tvertex;
                    t[rankDeletedIndex] = survivedIndex;

                    int SurvivedAttrib;
                    if (AttributeMapping.TryGetValue(t.GetAttributeIndex(rankDeletedIndex), out SurvivedAttrib))
                        t.SetAttributeIndex(rankDeletedIndex, SurvivedAttrib);
                    trisTouchingSurvivedVertexOnly.Add(t);
                }

                // attach edges to survided vertex
                edgeAssessed.isDeleted = true;
                for (int i = 0; i < deletedVertex.ecount; i++)
                {
                    edgeToMove = vtx2edges[deletedVertex.estart + i];
                    if (!edgeToMove.isDeleted)
                    {
                        ulong dkey;
                        if (edgeToMove.vertexA == deletedIndex)
                            dkey = Edge.CalculateKey(survivedIndex, edgeToMove.vertexB);
                        else
                            dkey = Edge.CalculateKey(survivedIndex, edgeToMove.vertexA);
                        bool canAttach = true;
                        for (int j = 0; j < survivedVertex.ecount; j++)
                        {
                            if (vtx2edges[survivedVertex.estart + j].key == dkey)
                            {
                                canAttach = false;
                                survivedEdge = vtx2edges[survivedVertex.estart + j];
                                break;
                            }
                        }
                        if (canAttach)
                        {
                            edgeToMove.ReplaceVertex(deletedIndex, survivedIndex);
                        }
                        else
                        {
                            edgeToMove.isDeleted = true;
                            survivedEdge.isBorder2D |= edgeToMove.isBorder2D;
                            survivedEdge.isUVSeam |= edgeToMove.isUVSeam;
                            survivedEdge.isUVFoldover |= edgeToMove.isUVFoldover;
                        }
                    }
                }
                //
                // update references :
                //
                // 1- vertices to tris
                int tstart = this.vtx2tris.Length;
                foreach (var t in trisTouchingSurvivedVertexOnly)
                    this.vtx2tris.Add(t.refCached);
                int tcount = this.vtx2tris.Length - tstart;
                survivedVertex.tstart = tstart;
                survivedVertex.tcount = tcount;
                deletedVertex.tcount = 0;
                // 2- vertices to edges
                int estart = this.vtx2edges.Length;
                for (int i = 0; i < survivedVertex.ecount; i++)
                {
                    survivedEdge = this.vtx2edges[survivedVertex.estart + i];
                    if (!survivedEdge.isDeleted)
                        this.vtx2edges.Add(survivedEdge);
                }
                for (int i = 0; i < deletedVertex.ecount; i++)
                {
                    survivedEdge = this.vtx2edges[deletedVertex.estart + i];
                    if (!survivedEdge.isDeleted)
                        this.vtx2edges.Add(survivedEdge);
                }
                int ecount = this.vtx2edges.Length - estart;
                survivedVertex.estart = estart;
                survivedVertex.ecount = ecount;
                deletedVertex.ecount = 0;
                vtx2edges = this.vtx2edges.Data;

                //
                survivedVertex.p = edgeAssessed.p;
                //
                // Update the matrices and error on the edges around survived vertex
                //
                //  step 1 - update quadrics error matrice Q at vertex V0 and at every vertex V1 connected to V0.
                //           Also border penalty matrices calculated on the edges need to be propagated to vertices.
                //  setp 2 - calculate edges error E and optimal vertex position p on all edges touching V0 and V1
                //
                {
                    Triangle t0, t1;
                    Vertex v0, v1;
                    Edge e0, e1;

                    // step 1 : update quadrics matrices
                    // 1a) reset all matrices
                    v0 = survivedVertex;
                    v0.q.Clear();
                    v0.qPenaltyEdge.Clear();

                    for (int i = 0; i < v0.ecount; i++)
                    {
                        e0 = vtx2edges[v0.estart + i];
                        // vertex at opposite end
                        if (e0.vertexA == v0.index)
                            v1 = vertices[e0.vertexB];
                        else
                            v1 = vertices[e0.vertexA];
                        v1.q.Clear();
                        v1.qPenaltyEdge.Clear();

                        for (int j = 0; j < v1.ecount; j++)
                        {
                            e1 = vtx2edges[v1.estart + j]; // note that one of the e1 is also e0
                            e1.qTwice.Clear();
                            e1.flagCalculateQstate = Edge.QState.QIsNotCalculated;
                        }
                    }
                    // 1b) Calculate quadrics matrices
                    for (int i = 0; i < v0.ecount; i++)
                    {
                        e0 = vtx2edges[v0.estart + i];
                        // vertex at opposite end
                        if (e0.vertexA == v0.index)
                            v1 = vertices[e0.vertexB];
                        else
                            v1 = vertices[e0.vertexA];

                        for (int j = 0; j < v1.ecount; j++)
                        {
                            e1 = vtx2edges[v1.estart + j]; // note that one of the e1 is also e0
                            for (int k = 0; k < v1.tcount; k++)
                            {
                                t1 = triangles[vtx2tris[v1.tstart + k].tid];
                                if (t1.deleted)
                                    continue;
                                if (e1.flagCalculateQstate != Edge.QState.QIsCalculated)
                                {
                                    // is e1 an edge of triangle t1 ?
                                    if (((e1.vertexA == t1.v0) || (e1.vertexA == t1.v1) || (e1.vertexA == t1.v2))
                                        && ((e1.vertexB == t1.v0) || (e1.vertexB == t1.v1) || (e1.vertexB == t1.v2)))
                                    {
                                        e1.qTwice.Add(ref t1.n, ref v1.p);
                                        // if e1 is an edge and it has not been evaluated then do it
                                        if (((e1.isBorder2D && PreserveBorderEdges) || (e1.isUVSeam && PreserveUVSeamEdges) || (e1.isUVFoldover && PreserveUVFoldoverEdges))
                                            && (e1.flagCalculateQstate == Edge.QState.QIsNotCalculated))
                                        {
                                            CalculateEdgePenaltyMatrix(t1, e1);
                                            e1.flagCalculateQstate = Edge.QState.QPenaltyIsCalculated;
                                        }
                                    }
                                }
                                v1.q.Add(ref t1.n, ref v1.p);
                            }
                            if ((e1.isBorder2D && PreserveBorderEdges) || (e1.isUVSeam && PreserveUVSeamEdges) || (e1.isUVFoldover && PreserveUVFoldoverEdges))
                                DistributeEdgePenaltyMatrix(e1, v1);
                            e1.flagCalculateQstate = Edge.QState.QIsCalculated;
                        }
                        if ((e0.isBorder2D && PreserveBorderEdges) || (e0.isUVSeam && PreserveUVSeamEdges) || (e0.isUVFoldover && PreserveUVFoldoverEdges))
                            DistributeEdgePenaltyMatrix(e0, v0);
                    }
                    for (int k = 0; k < v0.tcount; k++)
                    {
                        t0 = triangles[vtx2tris[v0.tstart + k].tid];
                        if (t0.deleted)
                            continue;
                        v0.q.Add(ref t0.n, ref v0.p);
                    }
                    // step 2 : update error
                    //// Note:
                    //// finally I will not update edge error beyond edge connected to vertex v0 for now because I have observed that:
                    //// 1- it reduces the execution time and
                    //// 2- the accuracy is better if I recalculate the edge error at the beginning of the main loop
                    for (int i = 0; i < v0.ecount; i++)
                    {
                        e0 = vtx2edges[v0.estart + i];
                        if (e0.flagCalculateQstate != Edge.QState.ErrorIsCalculated)
                        {
                            CalculateEdgeError(e0);
                            //DebugMeshPerf.Data.nrErrorEval++;
                            e0.flagCalculateQstate = Edge.QState.ErrorIsCalculated;
                        }
                    }
                }

                // try to collapse previously rejected edges. This improves quality for high reduction and low tris mesh
                if (edgesLRejected.Count >= recycleRejectedEdges)
                {
                    for (int i = 0; i < edgesLRejected.Count; i++)
                    {
                        edgeToMove = edgesLRejected[i];
                        if (!edgeToMove.isDeleted)
                        {
                            CalculateEdgeError(edgeToMove);
                            edgeToMove.errorKeyed = edgeToMove.error;
                            edgesL.AddSortedFromPosition(currentEdgeRank, edgeToMove);
                            //DebugMeshPerf.Data.nrEdgeReinsert++;
                            //DebugMeshPerf.Data.nrEdgeRejected--;
                        }
                    }
                    edgesLRejected.Clear();
                    recycleRejectedEdges += (int)((edgesL.Count - currentEdgeRank) * RecycleRejectedEdgesThreshold); // slow down rate to avoid stalling the algorithm; could be improved !
                }


                deletedTris += deletedCount;
                //DebugMeshPerf.Data.nrLoopComplete++;
            }

        }

        /// <summary>
        /// Simplifies the mesh to a desired quality.
        /// </summary>
        /// <param name="quality">The target quality (between 0 and 1).</param>
        private void SimplifyMeshByEdge(float quality)
        {
            quality = Mathf.Clamp01(quality);

            int deletedTris = 0;
            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            int trisToDelete = (int)(triangleCount * (1.0f - quality));

            //DebugMeshPerf.Data.Reset();
            
            UpdateMesh(0);
            InitEdges(out deletedTris);
            RemoveEdgePass(trisToDelete, ref deletedTris);




            if (trisToDelete > deletedTris)
            {
                //Debug.Log("Unable to delete the specified number of triangles");
            }

            CompactMesh();

            if (verbose)
            {
                //DebugMeshPerf.Data.nrTrisBefore = triangleCount;
                //DebugMeshPerf.Data.nrTrisAfter = triangleCount - deletedTris;
                //Debug.Log(DebugMeshPerf.Data);
            }
        }

        #endregion

        #endregion

        #region Public Methods
        #region Sub-Meshes
        /// <summary>
        /// Returns the triangle indices for all sub-meshes.
        /// </summary>
        /// <returns>The triangle indices for all sub-meshes.</returns>
        public int[][] GetAllSubMeshTriangles()
        {
            var indices = new int[subMeshCount][];
            for (int subMeshIndex = 0; subMeshIndex < subMeshCount; subMeshIndex++)
            {
                indices[subMeshIndex] = GetSubMeshTriangles(subMeshIndex);
            }
            return indices;
        }

        /// <summary>
        /// Returns the triangle indices for a specific sub-mesh.
        /// </summary>
        /// <param name="subMeshIndex">The sub-mesh index.</param>
        /// <returns>The triangle indices.</returns>
        public int[] GetSubMeshTriangles(int subMeshIndex)
        {
            if (subMeshIndex < 0)
                throw new ArgumentOutOfRangeException(nameof(subMeshIndex), "The sub-mesh index is negative.");

            // First get the sub-mesh offsets
            if (subMeshOffsets == null)
            {
                CalculateSubMeshOffsets();
            }

            if (subMeshIndex >= subMeshOffsets.Length)
                throw new ArgumentOutOfRangeException(nameof(subMeshIndex), "The sub-mesh index is greater than or equals to the sub mesh count.");
            else if (subMeshOffsets.Length != subMeshCount)
                throw new InvalidOperationException("The sub-mesh triangle offsets array is not the same size as the count of sub-meshes. This should not be possible to happen.");

            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;

            int startOffset = subMeshOffsets[subMeshIndex];
            if (startOffset >= triangleCount)
                return new int[0];

            int endOffset = ((subMeshIndex + 1) < subMeshCount ? subMeshOffsets[subMeshIndex + 1] : triangleCount);
            int subMeshTriangleCount = endOffset - startOffset;
            if (subMeshTriangleCount < 0) subMeshTriangleCount = 0;
            int[] subMeshIndices = new int[subMeshTriangleCount * 3];

            Debug.AssertFormat(startOffset >= 0, "The start sub mesh offset at index {0} was below zero ({1}).", subMeshIndex, startOffset);
            Debug.AssertFormat(endOffset >= 0, "The end sub mesh offset at index {0} was below zero ({1}).", subMeshIndex + 1, endOffset);
            Debug.AssertFormat(startOffset < triangleCount, "The start sub mesh offset at index {0} was higher or equal to the triangle count ({1} >= {2}).", subMeshIndex, startOffset, triangleCount);
            Debug.AssertFormat(endOffset <= triangleCount, "The end sub mesh offset at index {0} was higher than the triangle count ({1} > {2}).", subMeshIndex + 1, endOffset, triangleCount);

            for (int triangleIndex = startOffset; triangleIndex < endOffset; triangleIndex++)
            {
                var triangle = triangles[triangleIndex];
                int offset = (triangleIndex - startOffset) * 3;
                subMeshIndices[offset] = triangle.v0;
                subMeshIndices[offset + 1] = triangle.v1;
                subMeshIndices[offset + 2] = triangle.v2;
            }

            return subMeshIndices;
        }

        /// <summary>
        /// Clears out all sub-meshes.
        /// </summary>
        public void ClearSubMeshes()
        {
            subMeshCount = 0;
            subMeshOffsets = null;
            triangles.Resize(0);
        }

        /// <summary>
        /// Adds a sub-mesh triangle indices for a specific sub-mesh.
        /// </summary>
        /// <param name="triangles">The triangle indices.</param>
        public void AddSubMeshTriangles(int[] triangles)
        {
            if (triangles == null)
                throw new ArgumentNullException(nameof(triangles));
            else if ((triangles.Length % TriangleVertexCount) != 0)
                throw new ArgumentException("The index array length must be a multiple of 3 in order to represent triangles.", nameof(triangles));

            int subMeshIndex = subMeshCount++;
            int triangleIndexStart = this.triangles.Length;
            int subMeshTriangleCount = triangles.Length / TriangleVertexCount;
            this.triangles.Resize(this.triangles.Length + subMeshTriangleCount);
            var trisArr = this.triangles.Data;
            for (int i = 0; i < subMeshTriangleCount; i++)
            {
                int offset = i * 3;
                int v0 = triangles[offset];
                int v1 = triangles[offset + 1];
                int v2 = triangles[offset + 2];
                int triangleIndex = triangleIndexStart + i;
                trisArr[triangleIndex] = new Triangle(triangleIndex, v0, v1, v2, subMeshIndex);
            }
        }

        /// <summary>
        /// Adds several sub-meshes at once with their triangle indices for each sub-mesh.
        /// </summary>
        /// <param name="triangles">The triangle indices for each sub-mesh.</param>
        public void AddSubMeshTriangles(int[][] triangles)
        {
            if (triangles == null)
                throw new ArgumentNullException(nameof(triangles));

            int totalTriangleCount = 0;
            for (int i = 0; i < triangles.Length; i++)
            {
                if (triangles[i] == null)
                    throw new ArgumentException(string.Format("The index array at index {0} is null.", i));
                else if ((triangles[i].Length % TriangleVertexCount) != 0)
                    throw new ArgumentException(string.Format("The index array length at index {0} must be a multiple of 3 in order to represent triangles.", i), nameof(triangles));

                totalTriangleCount += triangles[i].Length / TriangleVertexCount;
            }

            int triangleIndexStart = this.triangles.Length;
            this.triangles.Resize(this.triangles.Length + totalTriangleCount);
            var trisArr = this.triangles.Data;

            for (int i = 0; i < triangles.Length; i++)
            {
                int subMeshIndex = subMeshCount++;
                var subMeshTriangles = triangles[i];
                int subMeshTriangleCount = subMeshTriangles.Length / TriangleVertexCount;

                for (int j = 0; j < subMeshTriangleCount; j++)
                {
                    int offset = j * 3;
                    int v0 = subMeshTriangles[offset];
                    int v1 = subMeshTriangles[offset + 1];
                    int v2 = subMeshTriangles[offset + 2];
                    int triangleIndex = triangleIndexStart + j;
                    Triangle triangle = new Triangle(triangleIndex, v0, v1, v2, subMeshIndex);
                    trisArr[triangleIndex] = triangle;

                    if (isPreservationActive)
                    {

                        Vertex vert1 = vertices[triangle.v0];
                        Vertex vert2 = vertices[triangle.v1];
                        Vertex vert3 = vertices[triangle.v2];

                        
                        foreach (var sphere in toleranceSpheres)
                        {
                            int count = 0;

                            if (VertexLiesInSphere(sphere, triangle, vert1)) { count++; }

                            if (VertexLiesInSphere(sphere, triangle, vert2)) { count++; }

                            if (VertexLiesInSphere(sphere, triangle, vert3)) { count++; }


                            if (count >= 2)
                            {
                                triangle.enclosingSpheres.Add(sphere);
                                sphere.currentEnclosedTrianglesCount++;

                                if (!trianglesInToleranceSpheres.Contains(triangle))
                                {
                                    trianglesInToleranceSpheres.Add(triangle);
                                }
                            }
                        }
                    }
                }
                
                triangleIndexStart += subMeshTriangleCount;
            }

            if (isPreservationActive)
            {
                foreach (var sphere in toleranceSpheres)
                {
                    sphere.SetInitialEnclosedTrianglesCount(sphere.currentEnclosedTrianglesCount);
                    //Debug.Log("Enclosing triangles  " + sphere.initialEnclosedTrianglesCount);
                }
            }
        }
        #endregion

        #region UV Sets
        #region Getting
        /// <summary>
        /// Returns the UVs (2D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <returns>The UVs.</returns>
        public Vector2[] GetUVs2D(int channel)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (vertUV2D != null && vertUV2D[channel] != null)
            {
                return vertUV2D[channel].Data;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Returns the UVs (3D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <returns>The UVs.</returns>
        public Vector3[] GetUVs3D(int channel)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (vertUV3D != null && vertUV3D[channel] != null)
            {
                return vertUV3D[channel].Data;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Returns the UVs (4D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <returns>The UVs.</returns>
        public Vector4[] GetUVs4D(int channel)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (vertUV4D != null && vertUV4D[channel] != null)
            {
                return vertUV4D[channel].Data;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Returns the UVs (2D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void GetUVs(int channel, List<Vector2> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));
            else if (uvs == null)
                throw new ArgumentNullException(nameof(uvs));

            uvs.Clear();
            if (vertUV2D != null && vertUV2D[channel] != null)
            {
                var uvData = vertUV2D[channel].Data;
                if (uvData != null)
                {
                    uvs.AddRange(uvData);
                }
            }
        }

        /// <summary>
        /// Returns the UVs (3D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void GetUVs(int channel, List<Vector3> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));
            else if (uvs == null)
                throw new ArgumentNullException(nameof(uvs));

            uvs.Clear();
            if (vertUV3D != null && vertUV3D[channel] != null)
            {
                var uvData = vertUV3D[channel].Data;
                if (uvData != null)
                {
                    uvs.AddRange(uvData);
                }
            }
        }

        /// <summary>
        /// Returns the UVs (4D) from a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void GetUVs(int channel, List<Vector4> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));
            else if (uvs == null)
                throw new ArgumentNullException(nameof(uvs));

            uvs.Clear();
            if (vertUV4D != null && vertUV4D[channel] != null)
            {
                var uvData = vertUV4D[channel].Data;
                if (uvData != null)
                {
                    uvs.AddRange(uvData);
                }
            }
        }
        #endregion

        #region Setting
        /// <summary>
        /// Sets the UVs (2D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, Vector2[] uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Length > 0)
            {
                if (vertUV2D == null)
                    vertUV2D = new UVChannels<Vector2>();

                int uvCount = uvs.Length;
                var uvSet = vertUV2D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector2>(uvCount, uvCount);
                    vertUV2D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV2D != null)
                {
                    vertUV2D[channel] = null;
                }
            }

            if (vertUV3D != null)
            {
                vertUV3D[channel] = null;
            }
            if (vertUV4D != null)
            {
                vertUV4D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs (3D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, Vector3[] uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Length > 0)
            {
                if (vertUV3D == null)
                    vertUV3D = new UVChannels<Vector3>();

                int uvCount = uvs.Length;
                var uvSet = vertUV3D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector3>(uvCount, uvCount);
                    vertUV3D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV3D != null)
                {
                    vertUV3D[channel] = null;
                }
            }

            if (vertUV2D != null)
            {
                vertUV2D[channel] = null;
            }
            if (vertUV4D != null)
            {
                vertUV4D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs (4D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, Vector4[] uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Length > 0)
            {
                if (vertUV4D == null)
                    vertUV4D = new UVChannels<Vector4>();

                int uvCount = uvs.Length;
                var uvSet = vertUV4D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector4>(uvCount, uvCount);
                    vertUV4D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV4D != null)
                {
                    vertUV4D[channel] = null;
                }
            }

            if (vertUV2D != null)
            {
                vertUV2D[channel] = null;
            }
            if (vertUV3D != null)
            {
                vertUV3D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs (2D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, List<Vector2> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Count > 0)
            {
                if (vertUV2D == null)
                    vertUV2D = new UVChannels<Vector2>();

                int uvCount = uvs.Count;
                var uvSet = vertUV2D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector2>(uvCount, uvCount);
                    vertUV2D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV2D != null)
                {
                    vertUV2D[channel] = null;
                }
            }

            if (vertUV3D != null)
            {
                vertUV3D[channel] = null;
            }
            if (vertUV4D != null)
            {
                vertUV4D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs (3D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, List<Vector3> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Count > 0)
            {
                if (vertUV3D == null)
                    vertUV3D = new UVChannels<Vector3>();

                int uvCount = uvs.Count;
                var uvSet = vertUV3D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector3>(uvCount, uvCount);
                    vertUV3D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV3D != null)
                {
                    vertUV3D[channel] = null;
                }
            }

            if (vertUV2D != null)
            {
                vertUV2D[channel] = null;
            }
            if (vertUV4D != null)
            {
                vertUV4D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs (4D) for a specific channel.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVs(int channel, List<Vector4> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Count > 0)
            {
                if (vertUV4D == null)
                    vertUV4D = new UVChannels<Vector4>();

                int uvCount = uvs.Count;
                var uvSet = vertUV4D[channel];
                if (uvSet != null)
                {
                    uvSet.Resize(uvCount);
                }
                else
                {
                    uvSet = new ResizableArray<Vector4>(uvCount, uvCount);
                    vertUV4D[channel] = uvSet;
                }

                var uvData = uvSet.Data;
                uvs.CopyTo(uvData, 0);
            }
            else
            {
                if (vertUV4D != null)
                {
                    vertUV4D[channel] = null;
                }
            }

            if (vertUV2D != null)
            {
                vertUV2D[channel] = null;
            }
            if (vertUV3D != null)
            {
                vertUV3D[channel] = null;
            }
        }

        /// <summary>
        /// Sets the UVs for a specific channel and automatically detects the used components.
        /// </summary>
        /// <param name="channel">The channel index.</param>
        /// <param name="uvs">The UVs.</param>
        public void SetUVsAuto(int channel, List<Vector4> uvs)
        {
            if (channel < 0 || channel >= UVChannelCount)
                throw new ArgumentOutOfRangeException(nameof(channel));

            if (uvs != null && uvs.Count > 0)
            {
                int usedComponents = MeshUtils.GetUsedUVComponents(uvs);
                if (usedComponents <= 2)
                {
                    var uv2D = MeshUtils.ConvertUVsTo2D(uvs);
                    SetUVs(channel, uv2D);
                }
                else if (usedComponents == 3)
                {
                    var uv3D = MeshUtils.ConvertUVsTo3D(uvs);
                    SetUVs(channel, uv3D);
                }
                else
                {
                    SetUVs(channel, uvs);
                }
            }
            else
            {
                if (vertUV2D != null)
                {
                    vertUV2D[channel] = null;
                }
                if (vertUV3D != null)
                {
                    vertUV3D[channel] = null;
                }
                if (vertUV4D != null)
                {
                    vertUV4D[channel] = null;
                }
            }
        }
        #endregion
        #endregion

        #region Blend Shapes
        /// <summary>
        /// Returns all blend shapes.
        /// </summary>
        /// <returns>An array of all blend shapes.</returns>
        public BlendShape[] GetAllBlendShapes()
        {
            if (blendShapes == null)
                return null;

            var results = new BlendShape[blendShapes.Length];
            for (int i = 0; i < results.Length; i++)
            {
                results[i] = blendShapes[i].ToBlendShape();
            }
            return results;
        }

        /// <summary>
        /// Returns a specific blend shape.
        /// </summary>
        /// <param name="blendShapeIndex">The blend shape index.</param>
        /// <returns>The blend shape.</returns>
        public BlendShape GetBlendShape(int blendShapeIndex)
        {
            if (blendShapes == null || blendShapeIndex < 0 || blendShapeIndex >= blendShapes.Length)
                throw new ArgumentOutOfRangeException(nameof(blendShapeIndex));

            return blendShapes[blendShapeIndex].ToBlendShape();
        }

        /// <summary>
        /// Clears all blend shapes.
        /// </summary>
        public void ClearBlendShapes()
        {
            if (blendShapes != null)
            {
                blendShapes.Clear();
                blendShapes = null;
            }
        }

        /// <summary>
        /// Adds a blend shape.
        /// </summary>
        /// <param name="blendShape">The blend shape to add.</param>
        public void AddBlendShape(BlendShape blendShape)
        {
            var frames = blendShape.Frames;
            if (frames == null || frames.Length == 0)
                throw new ArgumentException("The frames cannot be null or empty.", nameof(blendShape));

            if (this.blendShapes == null)
            {
                this.blendShapes = new ResizableArray<BlendShapeContainer>(4, 0);
            }

            var container = new BlendShapeContainer(blendShape);
            this.blendShapes.Add(container);
        }

        /// <summary>
        /// Adds several blend shapes.
        /// </summary>
        /// <param name="blendShapes">The blend shapes to add.</param>
        public void AddBlendShapes(BlendShape[] blendShapes)
        {
            if (blendShapes == null)
                throw new ArgumentNullException(nameof(blendShapes));

            if (this.blendShapes == null)
            {
                this.blendShapes = new ResizableArray<BlendShapeContainer>(Math.Max(4, blendShapes.Length), 0);
            }

            for (int i = 0; i < blendShapes.Length; i++)
            {
                var frames = blendShapes[i].Frames;
                if (frames == null || frames.Length == 0)
                    throw new ArgumentException(string.Format("The frames of blend shape at index {0} cannot be null or empty.", i), nameof(blendShapes));

                var container = new BlendShapeContainer(blendShapes[i]);
                this.blendShapes.Add(container);
            }
        }
        #endregion

        #region Initialize
        /// <summary>
        /// Initializes the algorithm with the original mesh.
        /// </summary>
        /// <param name="mesh">The mesh.</param>
        public void Initialize(Mesh mesh, bool isPreservationActive = false)
        {
            if (mesh == null)
                throw new ArgumentNullException(nameof(mesh));

            this.meshToSimplify = mesh;
            this.isPreservationActive = isPreservationActive;

            this.Vertices = mesh.vertices;
            this.Normals = mesh.normals;
            this.Tangents = mesh.tangents;

            this.Colors = mesh.colors;
            this.BoneWeights = mesh.boneWeights;
            this.bindposes = mesh.bindposes;

            for (int channel = 0; channel < UVChannelCount; channel++)
            {
                var uvs = MeshUtils.GetMeshUVs(mesh, channel);
                SetUVsAuto(channel, uvs);
            }

            var blendShapes = MeshUtils.GetMeshBlendShapes(mesh);


            if (blendShapes != null && blendShapes.Length > 0)
            {
                AddBlendShapes(blendShapes);
            }

            ClearSubMeshes();

            int subMeshCount = mesh.subMeshCount;
            var subMeshTriangles = new int[subMeshCount][];
            for (int i = 0; i < subMeshCount; i++)
            {
                subMeshTriangles[i] = mesh.GetTriangles(i);
            }
            AddSubMeshTriangles(subMeshTriangles);
        }
        #endregion

        #region Simplify Mesh
        /// <summary>
        /// Simplifies the mesh to a desired quality.
        /// </summary>
        /// <param name="quality">The target quality (between 0 and 1).</param>
        public void SimplifyMesh(float quality)
        {
            if (UseSortedEdgeMethod)
            {
                SimplifyMeshByEdge(quality);
                return;
            }

            quality = Mathf.Clamp01(quality);

            int deletedTris = 0;
            ResizableArray<bool> deleted0 = new ResizableArray<bool>(20);
            ResizableArray<bool> deleted1 = new ResizableArray<bool>(20);
            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            int startTrisCount = triangleCount;
            var vertices = this.vertices.Data;
            int targetTrisCount = Mathf.RoundToInt(triangleCount * quality);

            var maxIterationCount = MaxIterationCount;
            var agressiveness = Aggressiveness;
            for (int iteration = 0; iteration < maxIterationCount; iteration++)
            {
                if ((startTrisCount - deletedTris) <= targetTrisCount)
                    break;

                // Update mesh once in a while
                if ((iteration % 5) == 0)
                {
                    UpdateMesh(iteration);
                    triangles = this.triangles.Data;
                    triangleCount = this.triangles.Length;
                    vertices = this.vertices.Data;
                }

                // Clear dirty flag
                for (int i = 0; i < triangleCount; i++)
                {
                    triangles[i].dirty = false;
                }

                // All triangles with edges below the threshold will be removed
                //
                // The following numbers works well for most models.
                // If it does not, try to adjust the 3 parameters
                double threshold = 0.000000001 * Math.Pow(iteration + 3, agressiveness);

                if (verbose)
                {
                    Debug.LogFormat("iteration {0} - triangles {1} threshold {2}", iteration, (startTrisCount - deletedTris), threshold);
                }

                // Remove vertices & mark deleted triangles
                if (isPreservationActive)
                {
                    RemoveVertexPass(startTrisCount, targetTrisCount, threshold, deleted0, deleted1, ref deletedTris, isPreservationActive);
                }
                else
                {
                    RemoveVertexPass(startTrisCount, targetTrisCount, threshold, deleted0, deleted1, ref deletedTris);
                }
            }

            CompactMesh();

            if (verbose)
            {
                Debug.LogFormat("Finished simplification with triangle count {0}", this.triangles.Length);
            }
        }

        /// <summary>
        /// Simplifies the mesh without losing too much quality.
        /// </summary>
        public void SimplifyMeshLossless()
        {
            int deletedTris = 0;
            ResizableArray<bool> deleted0 = new ResizableArray<bool>(0);
            ResizableArray<bool> deleted1 = new ResizableArray<bool>(0);
            var triangles = this.triangles.Data;
            int triangleCount = this.triangles.Length;
            int startTrisCount = triangleCount;
            var vertices = this.vertices.Data;

            for (int iteration = 0; iteration < 9999; iteration++)
            {
                // Update mesh constantly
                UpdateMesh(iteration);
                triangles = this.triangles.Data;
                triangleCount = this.triangles.Length;
                vertices = this.vertices.Data;

                // Clear dirty flag
                for (int i = 0; i < triangleCount; i++)
                {
                    triangles[i].dirty = false;
                }

                // All triangles with edges below the threshold will be removed
                //
                // The following numbers works well for most models.
                // If it does not, try to adjust the 3 parameters
                double threshold = DoubleEpsilon;

                if (verbose)
                {
                    Debug.LogFormat("Lossless iteration {0} - triangles {1}", iteration, triangleCount);
                }


                // Remove vertices & mark deleted triangles
                if (isPreservationActive)
                {
                    RemoveVertexPass(startTrisCount, 0, threshold, deleted0, deleted1, ref deletedTris, isPreservationActive);
                }
                else
                {
                    RemoveVertexPass(startTrisCount, 0, threshold, deleted0, deleted1, ref deletedTris);
                }

                if (deletedTris <= 0)
                    break;

                deletedTris = 0;
            }

            CompactMesh();

            if (verbose)
            {
                Debug.LogFormat("Finished simplification with triangle count {0}", this.triangles.Length);
            }
        }
        #endregion

        #region To Mesh
        /// <summary>
        /// Returns the resulting mesh.
        /// </summary>
        /// <returns>The resulting mesh.</returns>
        public Mesh ToMesh()
        {
            var vertices = this.Vertices;
            var normals = this.Normals;
            var tangents = this.Tangents;
            var colors = this.Colors;
            var boneWeights = this.BoneWeights;
            var indices = GetAllSubMeshTriangles();
            var blendShapes = GetAllBlendShapes();

            List<Vector2>[] uvs2D = null;
            List<Vector3>[] uvs3D = null;
            List<Vector4>[] uvs4D = null;
            if (vertUV2D != null)
            {
                uvs2D = new List<Vector2>[UVChannelCount];
                for (int channel = 0; channel < UVChannelCount; channel++)
                {
                    if (vertUV2D[channel] != null)
                    {
                        var uvs = new List<Vector2>(vertices.Length);
                        GetUVs(channel, uvs);
                        uvs2D[channel] = uvs;
                    }
                }
            }

            if (vertUV3D != null)
            {
                uvs3D = new List<Vector3>[UVChannelCount];
                for (int channel = 0; channel < UVChannelCount; channel++)
                {
                    if (vertUV3D[channel] != null)
                    {
                        var uvs = new List<Vector3>(vertices.Length);
                        GetUVs(channel, uvs);
                        uvs3D[channel] = uvs;
                    }
                }
            }

            if (vertUV4D != null)
            {
                uvs4D = new List<Vector4>[UVChannelCount];
                for (int channel = 0; channel < UVChannelCount; channel++)
                {
                    if (vertUV4D[channel] != null)
                    {
                        var uvs = new List<Vector4>(vertices.Length);
                        GetUVs(channel, uvs);
                        uvs4D[channel] = uvs;
                    }
                }
            }

            Mesh created = MeshUtils.CreateMesh(vertices, indices, normals, tangents, colors, boneWeights, uvs2D, uvs3D, uvs4D, bindposes, blendShapes);

            return created;
        }
        #endregion

        private bool TriangleLiesInSphere(Triangle triangle)
        {

            //Might or might not delete, depends on the tolerance spheres preservation strength
            if (IsTriangleInAnyToleranceSphere(triangle))
            {
                foreach (var sphere in triangle.enclosingSpheres)
                {
                    if (sphere.currentEnclosedTrianglesCount <= sphere.leastTrianglesCount)
                    {
                        //Debug.Log($"preservationStrength  {sphere.preservationStrength }  enclosedTrianglesCount  {sphere.currentEnclosedTrianglesCount}  leastTrianglesCount  {sphere.leastTrianglesCount}");
                        return true;
                    }
                }


                spheresToSubtract = new ToleranceSphere[triangle.enclosingSpheres.Count];
                int a = 0;

                foreach (var sphere in triangle.enclosingSpheres)
                {
                    spheresToSubtract[a] = sphere;
                    a++;
                }

                return false;
            }

            //Might get deleted depending on the vertices error
            else
            {
                return false;
            }

        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private bool VertexLiesInSphere(ToleranceSphere sphere, Triangle containingTri, Vertex vertex)
        {

            if (isSkinned)
            {

                BoneWeight weight = new BoneWeight();
                int iSrc = containingTri.v0;

                if (vertBoneWeights != null)
                {
                    weight = vertBoneWeights[iSrc];
                }

                Matrix4x4[] t = new Matrix4x4[4];


                if (bonesOriginal.Length == 0)
                {
                    Vector3 vertexPosWorld = new Vector3((float)vertex.p.x, (float)vertex.p.y, (float)vertex.p.z);

                    vertexPosWorld = sphere.localToWorldMatrix.MultiplyPoint3x4(vertexPosWorld);

                    float x1 = (float)Math.Pow((vertexPosWorld.x - sphere.worldPosition.x), 2);
                    float y1 = (float)Math.Pow((vertexPosWorld.y - sphere.worldPosition.y), 2);
                    float z1 = (float)Math.Pow((vertexPosWorld.z - sphere.worldPosition.z), 2);

                    float dist = (x1 + y1 + z1);
                    float sphereRadius = sphere.diameter / 2f;

                    if (dist < (sphereRadius * sphereRadius)) { return true; }
                }

                else
                {

                    t[0] = transformations[bonesOriginal[weight.boneIndex0].GetHashCode()];
                    t[1] = transformations[bonesOriginal[weight.boneIndex1].GetHashCode()];
                    t[2] = transformations[bonesOriginal[weight.boneIndex2].GetHashCode()];
                    t[3] = transformations[bonesOriginal[weight.boneIndex3].GetHashCode()];

                    Vector3? vector = GetVertexWorldPosition(new Vector3((float)vertex.p.x, (float)vertex.p.y, (float)vertex.p.z), weight, boneWeightsOriginal, bindPosesOriginal, bonesOriginal, t);

                    Vector3 v = vector == null ? Vector3.zero : (Vector3)vector;

                    float x1 = (float)Math.Pow((v.x - sphere.worldPosition.x), 2);
                    float y1 = (float)Math.Pow((v.y - sphere.worldPosition.y), 2);
                    float z1 = (float)Math.Pow((v.z - sphere.worldPosition.z), 2);

                    float dist = (x1 + y1 + z1);
                    float sphereRadius = sphere.diameter / 2f;

                    if (dist < (sphereRadius * sphereRadius)) { return true; }

                }

                return false;
            }

            else
            {
                
                Vector3 vertexPosWorld = new Vector3((float)vertex.p.x, (float)vertex.p.y, (float)vertex.p.z);
                vertexPosWorld = sphere.localToWorldMatrix.MultiplyPoint3x4(vertexPosWorld);

                float x1 = (float)Math.Pow((vertexPosWorld.x - sphere.worldPosition.x), 2);
                float y1 = (float)Math.Pow((vertexPosWorld.y - sphere.worldPosition.y), 2);
                float z1 = (float)Math.Pow((vertexPosWorld.z - sphere.worldPosition.z), 2);

                float dist = (x1 + y1 + z1);
                float sphereRadius = sphere.diameter / 2f;


                if (dist < (sphereRadius * sphereRadius)) { return true; }

                return false;
            }

        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private bool IsTriangleInAnyToleranceSphere(Triangle triangle)
        {
            return trianglesInToleranceSpheres.Contains(triangle);
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private HashSet<Triangle> GetTrianglesContainingVertex(ref Vertex toCheck)
        {
            int trianglesCount = toCheck.tcount;
            int startIndex = toCheck.tstart;

            HashSet<Triangle> tris = new HashSet<Triangle>();

            for (int a = startIndex; a < startIndex + trianglesCount; a++)
            {
                tris.Add(triangles[vtx2tris[a].tid]);
            }

            return tris;
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private HashSet<Triangle> GetTrianglesContainingBothVertices(ref Vertex vertex1, ref Vertex vertex2)
        {
            HashSet<Triangle> tris = new HashSet<Triangle>();


            int trianglesCount = vertex1.tcount;
            int startIndex = vertex1.tstart;
            int hashcode = vertex2.GetHashCode();

            for (int a = startIndex; a < startIndex + trianglesCount; a++)
            {
                Triangle tri = triangles[vtx2tris[a].tid];

                Vertex v1 = vertices[tri.v0];
                Vertex v2 = vertices[tri.v1];
                Vertex v3 = vertices[tri.v2];

                if (v1.GetHashCode().Equals(hashcode) || v2.GetHashCode().Equals(hashcode) || v3.GetHashCode().Equals(hashcode))
                {
                    tris.Add(tri);
                }

            }

            return tris;
        }


        private bool TriangleContainsVertex(Triangle triangle, Vertex vertex)
        {
            int hashcode = vertex.GetHashCode();

            Vertex v1 = vertices[triangle.v0];
            Vertex v2 = vertices[triangle.v1];
            Vertex v3 = vertices[triangle.v2];

            if (v1.GetHashCode().Equals(hashcode) || v2.GetHashCode().Equals(hashcode) || v3.GetHashCode().Equals(hashcode))
            {
                return true;
            }

            else { return false; }
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3? GetVertexWorldPosition(Vector3 vertexLocalPosition, BoneWeight bw, BoneWeight[] boneWeights, Matrix4x4[] aBindPoses, Transform[] aBones, Matrix4x4[] transformMatrices)
        {

            Vector3? worldPosition = null;


            if (meshToSimplify == null)
            {
                return null;
            }


            if (boneWeights == null || aBindPoses == null || aBones == null)
            {
                return null;
            }

            if (aBindPoses.Length == 0 || aBones.Length == 0)
            {
                return null;
            }


            worldPosition = Vector3.zero;
            Vector3 v3LocalVertex;

            if (Math.Abs(bw.weight0) > 0.00001f)
            {
                v3LocalVertex = aBindPoses[bw.boneIndex0].MultiplyPoint3x4(vertexLocalPosition);
                worldPosition += transformMatrices[0].MultiplyPoint3x4(v3LocalVertex) * bw.weight0;
            }
            if (Math.Abs(bw.weight1) > 0.00001f)
            {
                v3LocalVertex = aBindPoses[bw.boneIndex1].MultiplyPoint3x4(vertexLocalPosition);
                worldPosition += transformMatrices[1].MultiplyPoint3x4(v3LocalVertex) * bw.weight1;
            }
            if (Math.Abs(bw.weight2) > 0.00001f)
            {
                v3LocalVertex = aBindPoses[bw.boneIndex2].MultiplyPoint3x4(vertexLocalPosition);
                worldPosition += transformMatrices[2].MultiplyPoint3x4(v3LocalVertex) * bw.weight2;
            }
            if (Math.Abs(bw.weight3) > 0.00001f)
            {
                v3LocalVertex = aBindPoses[bw.boneIndex3].MultiplyPoint3x4(vertexLocalPosition);
                worldPosition += transformMatrices[3].MultiplyPoint3x4(v3LocalVertex) * bw.weight3;
            }

            return worldPosition;

        }

        #endregion
    }

    #region DebugInfo
    // a singleton to collect stats on algo flow
    internal class DebugMeshPerf
    {
        public int nrErrorEval = 0;
        public int nrEdgeReinsert = 0;
        public int nrLoopTest = 0;
        public int nrLoopComplete = 0;
        public int nrErrorTypeEllipsoid = 0;
        public int nrErrorTypeVertex = 0;
        public int nrBorder2D = 0;
        public int nrUVSeamEdge = 0;
        public int nrUVFoldoverEdge = 0;
        public int nrEdgeLag = 0;
        public int nrEdgeRejected = 0;
        public int nrTrisBefore = 0;
        public int nrTrisAfter = 0;
        public double lastErrorValue = 0;
        public int[] Triplets = new int[3];

        private DebugMeshPerf() { }

        public void Reset()
        {
            singleton = new DebugMeshPerf();
        }

        private static DebugMeshPerf singleton;

        public static DebugMeshPerf Data
        {
            get
            {
                if (singleton == null)
                    singleton = new DebugMeshPerf();
                return singleton;
            }
        }

        public override string ToString()
        {
            return string.Format(
                "Tris before = {0}, tris after = {1}, Error = {2}" +
                "\nMainloop(Lag:{3}, Rejected:{4} ErrorQEval:{5}, Reinsert:{6}, Loop:{7}, DeletedEdges:{8})" +
                "\nErrorQProfil(Ellipse:{9},Vertex:{10})" +
                "\nBorder 2D edges:{11}, UVSeamEdges:{12}, UVFoldoverEdges:{13}" +
                "\nEigenValue: {14};{15};{16}"
                , nrTrisBefore, nrTrisAfter, lastErrorValue
                , nrEdgeLag, nrEdgeRejected, nrErrorEval, nrEdgeReinsert, nrLoopTest, nrLoopComplete
                , nrErrorTypeEllipsoid, nrErrorTypeVertex
                , nrBorder2D, nrUVSeamEdge, nrUVFoldoverEdge
                , Triplets[0], Triplets[1], Triplets[2]);
        }

        /// <summary>
        /// Quadrics error display.
        /// This function will add a color at  each vertex to create a heat map representing quadrics error.
        /// Use a Particles/Standard unlit shader set to Opaque/Color to display the heat map.
        /// </summary>
        /// <param name="vertices"></param>
        /// <param name="v2e"></param>
        /// <returns></returns>
        public static Color[] UpdateVertexColor(Vertex[] vertices, Edge[] v2e)
        {
            Color colorErrorSmall = Color.green;
            Color colorErrorLarge = Color.yellow;
            Color[] colors = new Color[vertices.Length];
            Vertex v;
            Edge e;
            for (int i = 0; i < vertices.Length; i++)
            {
                v = vertices[i];
                double errTrace, err = 0, errMax = 0, errMin = double.MaxValue, errAvg = 0;
                if (v.ecount > 0)
                {
                    for (int j = 0; j < v.ecount; j++)
                    {
                        e = v2e[v.estart + j];
                        err = e.error;
                        errAvg += err;
                        errMin = Math.Min(errMin, err);
                        errMax = Math.Max(errMax, err);
                    }
                    errAvg /= v.ecount;
                }
                // display the error max at vertex
                if (errMin > 0)
                    errTrace = (-Math.Log10(errMin) + 1) / 10;
                else
                    errTrace = 1;
                colors[i] = Color.Lerp(colorErrorLarge, colorErrorSmall, Mathf.Clamp01((float)errTrace));
            }
            return colors;
        }
    }
}
#endregion