Ejemplo n.º 1
0
        private void InitializeSortedNeighboringInternalVertices(DecalsMesh a_DecalsMesh, int a_VertexIndex)
        {
            this.m_SortedNeighboringVerticesInitialized = true;
            this.m_UnusedNeighboringTriangles.AddRange(this.m_NeighboringTriangles);
            int num  = this.m_UnusedNeighboringTriangles[this.m_UnusedNeighboringTriangles.Count - 1];
            int num2 = this.InnerTriangleIndexOfVertexIndex(a_DecalsMesh, num, a_VertexIndex);

            num2 = this.SuccessorInnerTriangleVertexIndex(num2);
            this.m_SortedNeighboringVertices.Add(a_DecalsMesh.Triangles[num + num2]);
            this.m_SortedNeighboringVertices.Add(a_DecalsMesh.Triangles[num + this.SuccessorInnerTriangleVertexIndex(num2)]);
            this.m_UnusedNeighboringTriangles.RemoveAt(this.m_UnusedNeighboringTriangles.Count - 1);
            while (true)
            {
                if (this.m_UnusedNeighboringTriangles.Count <= 1)
                {
                    break;
                }
                bool flag  = false;
                int  num3  = this.m_SortedNeighboringVertices[this.m_SortedNeighboringVertices.Count - 1];
                int  index = 0;
                while (true)
                {
                    if (index < this.m_UnusedNeighboringTriangles.Count)
                    {
                        int num5 = this.m_UnusedNeighboringTriangles[index];
                        int num6 = this.InnerTriangleIndexOfVertexIndex(a_DecalsMesh, num5, a_VertexIndex);
                        num6 = this.SuccessorInnerTriangleVertexIndex(num6);
                        int num7 = a_DecalsMesh.Triangles[num5 + num6];
                        if (num7 != num3)
                        {
                            index++;
                            continue;
                        }
                        int item = a_DecalsMesh.Triangles[num5 + this.SuccessorInnerTriangleVertexIndex(num6)];
                        this.m_SortedNeighboringVertices.Add(item);
                        this.m_UnusedNeighboringTriangles.RemoveAt(index);
                        flag = true;
                    }
                    if (!flag)
                    {
                        this.m_SortedNeighboringVerticesInitialized = false;
                    }
                    break;
                }
            }
            if (this.m_SortedNeighboringVerticesInitialized)
            {
                int num10 = this.m_UnusedNeighboringTriangles[0];
                int num11 = this.InnerTriangleIndexOfVertexIndex(a_DecalsMesh, num10, a_VertexIndex);
                num11 = this.SuccessorInnerTriangleVertexIndex(num11);
                if (this.m_SortedNeighboringVertices[this.m_SortedNeighboringVertices.Count - 1] != a_DecalsMesh.Triangles[num10 + num11])
                {
                    throw new InvalidOperationException("The last triangle doesn't match the previous ones.");
                }
                if (this.m_SortedNeighboringVertices[0] != a_DecalsMesh.Triangles[num10 + this.SuccessorInnerTriangleVertexIndex(num11)])
                {
                    throw new InvalidOperationException("The last triangle doesn't match to the first one.");
                }
            }
        }
Ejemplo n.º 2
0
 public void MinimizeActiveProjectorOfDecalsMesh(DecalsMesh a_DecalsMesh, float a_MaximumAbsoluteError, float a_MaximumRelativeError)
 {
     if (a_DecalsMesh == null)
     {
         throw new ArgumentNullException("Decals mesh argument is not allowed to be null.");
     }
     if (a_DecalsMesh.ActiveDecalProjector == null)
     {
         throw new ArgumentNullException("Active decal projector of decals mesh is not allowed to be null.");
     }
     if (a_MaximumAbsoluteError < 0f)
     {
         throw new ArgumentOutOfRangeException("The maximum absolute error has to be greater than zero.");
     }
     if ((a_MaximumRelativeError < 0f) || (a_MaximumRelativeError > 1f))
     {
         throw new ArgumentOutOfRangeException("The maximum relative error has to be within [0.0f, 1.0f].");
     }
     this.ClearAll();
     s_CurrentMaximumAbsoluteError = a_MaximumAbsoluteError;
     s_CurrentMaximumRelativeError = a_MaximumRelativeError;
     this.ComputePotentialObsoleteVertices(a_DecalsMesh);
     this.ComputeObsoleteInternalVertices(a_DecalsMesh);
     this.ComputeObsoleteExternalVertices(a_DecalsMesh);
     this.RemoveObsoleteVertices(a_DecalsMesh);
     this.ClearAll();
 }
Ejemplo n.º 3
0
 private void ComputeNeighbors(DecalsMesh a_DecalsMesh, int a_VertexIndex)
 {
     this.ClearNeighbors();
     for (int i = a_DecalsMesh.ActiveDecalProjector.DecalsMeshLowerTriangleIndex; i < a_DecalsMesh.Triangles.Count; i += 3)
     {
         this.AddNeighborTriangleIfNeeded(a_DecalsMesh, a_VertexIndex, i);
     }
 }
Ejemplo n.º 4
0
 private void ComputeNeighbors(DecalsMesh a_DecalsMesh, int a_VertexIndex, List <OptimizeEdge> a_RedundantInternalEdges)
 {
     this.ClearNeighbors();
     foreach (OptimizeEdge edge in a_RedundantInternalEdges)
     {
         this.AddNeighborTriangleIfNeeded(a_DecalsMesh, a_VertexIndex, edge.triangle1Index);
         this.AddNeighborTriangleIfNeeded(a_DecalsMesh, a_VertexIndex, edge.triangle2Index);
     }
 }
Ejemplo n.º 5
0
 private void AddTriangleNormal(DecalsMesh a_DecalsMesh, int a_TriangleIndex)
 {
     if (!this.m_TriangleNormals.HasTriangleNormal(a_TriangleIndex))
     {
         int     num     = a_DecalsMesh.Triangles[a_TriangleIndex];
         int     num2    = a_DecalsMesh.Triangles[a_TriangleIndex + 1];
         int     num3    = a_DecalsMesh.Triangles[a_TriangleIndex + 2];
         Vector3 vector4 = GeometryUtilities.TriangleNormal(a_DecalsMesh.Vertices[num], a_DecalsMesh.Vertices[num2], a_DecalsMesh.Vertices[num3]);
         this.m_TriangleNormals.AddTriangleNormal(a_TriangleIndex, vector4);
     }
 }
Ejemplo n.º 6
0
 private void ComputeObsoleteExternalVertices(DecalsMesh a_DecalsMesh)
 {
     for (int i = this.m_ObsoleteExternalVertexIndices.Count - 1; i >= 0; i--)
     {
         int num2 = this.m_ObsoleteExternalVertexIndices[i];
         if (!this.m_ObsoleteVertexFinder.IsExternalVertexObsolete(a_DecalsMesh, num2))
         {
             this.m_ObsoleteExternalVertexIndices.RemoveAt(i);
         }
     }
 }
Ejemplo n.º 7
0
        private void ComputeObsoleteInternalVertices(DecalsMesh a_DecalsMesh)
        {
            List <OptimizeEdge> list = this.m_RedundantInternalEdges.OptimizedEdgeList();

            for (int i = this.m_ObsoleteInternalVertexIndices.Count - 1; i >= 0; i--)
            {
                int num2 = this.m_ObsoleteInternalVertexIndices[i];
                if (!this.m_ObsoleteVertexFinder.IsInternalVertexObsolete(a_DecalsMesh, num2, list))
                {
                    this.m_ObsoleteInternalVertexIndices.RemoveAt(i);
                }
            }
        }
Ejemplo n.º 8
0
 private void AddNewTriangles(DecalsMesh a_DecalsMesh)
 {
     while (true)
     {
         bool flag;
         while (true)
         {
             if (this.m_SortedNeighboringVertices.Count >= 3)
             {
                 flag = false;
                 for (int i = 0; i < this.m_SortedNeighboringVertices.Count; i++)
                 {
                     int num2  = i;
                     int index = i + 1;
                     int num4  = i + 2;
                     if (index >= this.m_SortedNeighboringVertices.Count)
                     {
                         index -= this.m_SortedNeighboringVertices.Count;
                         num4  -= this.m_SortedNeighboringVertices.Count;
                     }
                     else if (num4 >= this.m_SortedNeighboringVertices.Count)
                     {
                         num4 -= this.m_SortedNeighboringVertices.Count;
                     }
                     int     item = this.m_SortedNeighboringVertices[num2];
                     int     num6 = this.m_SortedNeighboringVertices[index];
                     int     num7 = this.m_SortedNeighboringVertices[num4];
                     Vector3 rhs  = GeometryUtilities.TriangleNormal(a_DecalsMesh.Vertices[item], a_DecalsMesh.Vertices[num6], a_DecalsMesh.Vertices[num7]);
                     if (Vector3.Dot(this.m_ReferenceTriangleNormal, rhs) >= 0f)
                     {
                         a_DecalsMesh.Triangles.Add(item);
                         a_DecalsMesh.Triangles.Add(num6);
                         a_DecalsMesh.Triangles.Add(num7);
                         this.m_SortedNeighboringVertices.RemoveAt(index);
                         flag = true;
                         break;
                     }
                 }
             }
             else
             {
                 return;
             }
             break;
         }
         if (!flag)
         {
             return;
         }
     }
 }
Ejemplo n.º 9
0
        private void AddNeighborTriangleIfNeeded(DecalsMesh a_DecalsMesh, int a_VertexIndex, int a_TriangleIndex)
        {
            int  num  = a_DecalsMesh.Triangles[a_TriangleIndex];
            int  num2 = a_DecalsMesh.Triangles[a_TriangleIndex + 1];
            int  num3 = a_DecalsMesh.Triangles[a_TriangleIndex + 2];
            int  item = 0;
            int  num5 = 0;
            bool flag = true;

            if (a_VertexIndex == num)
            {
                item = num2;
                num5 = num3;
            }
            else if (a_VertexIndex == num2)
            {
                item = num;
                num5 = num3;
            }
            else if (a_VertexIndex != num3)
            {
                flag = false;
            }
            else
            {
                item = num;
                num5 = num2;
            }
            if (flag && !this.m_NeighboringTriangles.Contains(a_TriangleIndex))
            {
                this.m_NeighboringTriangles.Add(a_TriangleIndex);
                if (!this.m_NeighboringVertexIndices.Contains(item))
                {
                    float num6 = Vector3.Distance(a_DecalsMesh.Vertices[a_VertexIndex], a_DecalsMesh.Vertices[item]);
                    this.m_NeighboringVertexIndices.Add(item);
                    this.m_NeighboringVertexDistances.Add(num6);
                }
                if (!this.m_NeighboringVertexIndices.Contains(num5))
                {
                    float num7 = Vector3.Distance(a_DecalsMesh.Vertices[a_VertexIndex], a_DecalsMesh.Vertices[num5]);
                    this.m_NeighboringVertexIndices.Add(num5);
                    this.m_NeighboringVertexDistances.Add(num7);
                }
                this.AddTriangleNormal(a_DecalsMesh, a_TriangleIndex);
            }
        }
Ejemplo n.º 10
0
 internal void RemoveObsoleteInternalVertex(DecalsMesh a_DecalsMesh, int a_VertexIndex, List <OptimizeEdge> a_RedundantInternalEdges, out bool a_SuccessfulRemoval)
 {
     this.InitializeNeighboringTriangles(a_DecalsMesh, a_VertexIndex);
     this.InitializeSortedNeighboringInternalVertices(a_DecalsMesh, a_VertexIndex);
     if (!this.m_SortedNeighboringVerticesInitialized)
     {
         a_SuccessfulRemoval = false;
     }
     else
     {
         this.RemoveUnneededTriangles(a_DecalsMesh);
         this.AddNewTriangles(a_DecalsMesh);
         a_DecalsMesh.ActiveDecalProjector.DecalsMeshUpperTriangleIndex = a_DecalsMesh.Triangles.Count - 1;
         a_SuccessfulRemoval = true;
     }
     this.Clear();
 }
Ejemplo n.º 11
0
        private static bool AreEdgesParallelOrIsAtLeastOneAPoint(DecalsMesh a_DecalsMesh, OptimizeEdge a_Edge1, OptimizeEdge a_Edge2)
        {
            bool    flag    = false;
            Vector3 vector5 = a_DecalsMesh.Vertices[a_Edge1.vertex2Index] - a_DecalsMesh.Vertices[a_Edge1.vertex1Index];
            Vector3 vector6 = a_DecalsMesh.Vertices[a_Edge2.vertex2Index] - a_DecalsMesh.Vertices[a_Edge2.vertex1Index];

            vector5.Normalize();
            vector6.Normalize();
            if (Vector3Extension.Approximately(vector5, Vector3.zero, s_CurrentMaximumAbsoluteError, s_CurrentMaximumRelativeError) || Vector3Extension.Approximately(vector6, Vector3.zero, s_CurrentMaximumAbsoluteError, s_CurrentMaximumRelativeError))
            {
                flag = true;
            }
            else if (MathfExtension.Approximately(Mathf.Abs(Vector3.Dot(vector5, vector6)), 1f, s_CurrentMaximumAbsoluteError, s_CurrentMaximumRelativeError))
            {
                flag = true;
            }
            return(flag);
        }
Ejemplo n.º 12
0
        public void MinimizeActiveProjectorOfDecalsMesh(DecalsMesh a_DecalsMesh)
        {
            if (a_DecalsMesh == null)
            {
                throw new ArgumentNullException("Decals mesh argument is not allowed to be null.");
            }
            float meshMinimizerMaximumAbsoluteError = a_DecalsMesh.Decals.MeshMinimizerMaximumAbsoluteError;
            float meshMinimizerMaximumRelativeError = a_DecalsMesh.Decals.MeshMinimizerMaximumRelativeError;

            try
            {
                this.MinimizeActiveProjectorOfDecalsMesh(a_DecalsMesh, meshMinimizerMaximumAbsoluteError, meshMinimizerMaximumRelativeError);
            }
            catch
            {
                throw;
            }
        }
Ejemplo n.º 13
0
        private int InnerTriangleIndexOfVertexIndex(DecalsMesh a_DecalsMesh, int a_TriangleIndex, int a_VertexIndex)
        {
            int num;

            if (a_DecalsMesh.Triangles[a_TriangleIndex] == a_VertexIndex)
            {
                num = 0;
            }
            else if (a_DecalsMesh.Triangles[a_TriangleIndex + 1] == a_VertexIndex)
            {
                num = 1;
            }
            else
            {
                if (a_DecalsMesh.Triangles[a_TriangleIndex + 2] != a_VertexIndex)
                {
                    throw new InvalidOperationException("The vertex index argument is not in the provided triangle.");
                }
                num = 2;
            }
            return(num);
        }
Ejemplo n.º 14
0
        private void RemoveObsoleteVertices(DecalsMesh a_DecalsMesh)
        {
            DecalProjectorBase activeDecalProjector = a_DecalsMesh.ActiveDecalProjector;

            this.m_ObsoleteInternalVertexIndices.Sort();
            List <OptimizeEdge> list = this.m_RedundantInternalEdges.OptimizedEdgeList();

            for (int i = this.m_ObsoleteInternalVertexIndices.Count - 1; i >= 0; i--)
            {
                bool flag;
                int  num2 = this.m_ObsoleteInternalVertexIndices[i];
                this.m_ObsoleteVertexRemover.RemoveObsoleteInternalVertex(a_DecalsMesh, num2, list, out flag);
                if (!flag)
                {
                    this.m_ObsoleteInternalVertexIndices.RemoveAt(i);
                }
            }
            for (int j = this.m_ObsoleteExternalVertexIndices.Count - 1; j >= 0; j--)
            {
                bool flag2;
                int  num4 = this.m_ObsoleteExternalVertexIndices[j];
                this.m_ObsoleteVertexRemover.RemoveObsoleteExternalVertex(a_DecalsMesh, num4, out flag2);
                if (!flag2)
                {
                    this.m_ObsoleteExternalVertexIndices.RemoveAt(j);
                }
            }
            this.m_ObsoleteInternalVertexIndices.AddRange(this.m_ObsoleteExternalVertexIndices);
            this.m_ObsoleteInternalVertexIndices.Sort();
            foreach (int num5 in this.m_ObsoleteInternalVertexIndices)
            {
                this.m_RemovedIndices.AddRemovedIndex(num5);
            }
            a_DecalsMesh.RemoveAndAdjustIndices(activeDecalProjector.DecalsMeshLowerTriangleIndex, this.m_RemovedIndices);
            activeDecalProjector.IsUV1ProjectionCalculated     = false;
            activeDecalProjector.IsUV2ProjectionCalculated     = false;
            activeDecalProjector.IsTangentProjectionCalculated = false;
        }
Ejemplo n.º 15
0
        private void RemoveUnneededTriangles(DecalsMesh a_DecalsMesh)
        {
            this.m_NeighboringTriangles.Sort();
            int num = this.m_NeighboringTriangles.Count - 1;

            while (num >= 0)
            {
                int num2 = this.m_NeighboringTriangles[num];
                int num3 = 1;
                while (true)
                {
                    if ((num <= 0) || ((num2 - 3) != this.m_NeighboringTriangles[num - 1]))
                    {
                        a_DecalsMesh.RemoveTrianglesAt(num2, num3);
                        num--;
                        break;
                    }
                    num2 -= 3;
                    num3++;
                    num--;
                }
            }
        }
Ejemplo n.º 16
0
        private bool AreVertexPropertiesIdentical(DecalsMesh a_DecalsMesh, int a_VertexIndex1, int a_VertexIndex2)
        {
            Decals decals = a_DecalsMesh.Decals;
            bool   flag   = Vector3Extension.Approximately(a_DecalsMesh.Vertices[a_VertexIndex1], a_DecalsMesh.Vertices[a_VertexIndex2], DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);

            if (flag && (decals.CurrentNormalsMode == NormalsMode.Target))
            {
                flag = Vector3Extension.Approximately(a_DecalsMesh.Normals[a_VertexIndex1], a_DecalsMesh.Normals[a_VertexIndex2], DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
            }
            if (flag && (decals.CurrentTangentsMode == TangentsMode.Target))
            {
                Vector4 vector6 = a_DecalsMesh.Tangents[a_VertexIndex2];
                flag = Vector3Extension.Approximately(a_DecalsMesh.Tangents[a_VertexIndex1], (Vector3)vector6, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
            }
            if (flag && ((decals.CurrentUVMode == UVMode.TargetUV) || (decals.CurrentUVMode == UVMode.TargetUV2)))
            {
                flag = Vector2Extension.Approximately(a_DecalsMesh.UVs[a_VertexIndex1], a_DecalsMesh.UVs[a_VertexIndex2], DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
            }
            if (flag && ((decals.CurrentUV2Mode == UV2Mode.TargetUV) || (decals.CurrentUV2Mode == UV2Mode.TargetUV2)))
            {
                flag = Vector2Extension.Approximately(a_DecalsMesh.UV2s[a_VertexIndex1], a_DecalsMesh.UV2s[a_VertexIndex2], DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
            }
            return(flag);
        }
Ejemplo n.º 17
0
        private void InitializeNeighboringTriangles(DecalsMesh a_DecalsMesh, int a_VertexIndex)
        {
            bool flag = false;

            for (int i = a_DecalsMesh.ActiveDecalProjector.DecalsMeshLowerTriangleIndex; i < a_DecalsMesh.Triangles.Count; i += 3)
            {
                int num2 = a_DecalsMesh.Triangles[i];
                int num3 = a_DecalsMesh.Triangles[i + 1];
                int num4 = a_DecalsMesh.Triangles[i + 2];
                if ((num2 == a_VertexIndex) || ((num3 == a_VertexIndex) || (num4 == a_VertexIndex)))
                {
                    this.m_NeighboringTriangles.Add(i);
                    if (!flag)
                    {
                        Vector3 vector = a_DecalsMesh.Vertices[num2];
                        this.m_ReferenceTriangleNormal = GeometryUtilities.TriangleNormal(vector, a_DecalsMesh.Vertices[num3], a_DecalsMesh.Vertices[num4]);
                        if (!Vector3Extension.Approximately(this.m_ReferenceTriangleNormal, Vector3.zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError))
                        {
                            flag = true;
                        }
                    }
                }
            }
        }
Ejemplo n.º 18
0
 public bool IsInternalVertexObsolete(DecalsMesh a_DecalsMesh, int a_VertexIndex, List <OptimizeEdge> a_RedundantInternalEdges)
 {
     this.ClearAll();
     this.ComputeNeighbors(a_DecalsMesh, a_VertexIndex, a_RedundantInternalEdges);
     return(this.IsVertexObsolete(a_DecalsMesh, a_VertexIndex));
 }
Ejemplo n.º 19
0
        private void ComputePotentialObsoleteVertices(DecalsMesh a_DecalsMesh)
        {
            DecalProjectorBase activeDecalProjector = a_DecalsMesh.ActiveDecalProjector;

            this.ClearAll();
            for (int i = activeDecalProjector.DecalsMeshLowerTriangleIndex; i <= activeDecalProjector.DecalsMeshUpperTriangleIndex; i += 3)
            {
                int          num2  = a_DecalsMesh.Triangles[i];
                int          num3  = a_DecalsMesh.Triangles[i + 1];
                int          num4  = a_DecalsMesh.Triangles[i + 2];
                OptimizeEdge edge  = new OptimizeEdge(num2, num3, i);
                OptimizeEdge edge2 = new OptimizeEdge(num3, num4, i);
                OptimizeEdge edge3 = new OptimizeEdge(num4, num2, i);
                this.AddEdge(edge);
                this.AddEdge(edge2);
                this.AddEdge(edge3);
            }
            List <OptimizeEdge> list = this.m_RedundantExternalEdges.OptimizedEdgeList();

            foreach (OptimizeEdge edge4 in list)
            {
                if (!this.m_NonInternalVertexIndices.ContainsKey(edge4.vertex1Index))
                {
                    this.m_NonInternalVertexIndices.Add(edge4.vertex1Index, edge4.vertex1Index);
                }
                if (!this.m_NonInternalVertexIndices.ContainsKey(edge4.vertex2Index))
                {
                    this.m_NonInternalVertexIndices.Add(edge4.vertex2Index, edge4.vertex2Index);
                }
            }
            foreach (OptimizeEdge edge5 in this.m_OverusedInternalEdges.OptimizedEdgeList())
            {
                if (!this.m_NonInternalVertexIndices.ContainsKey(edge5.vertex1Index))
                {
                    this.m_NonInternalVertexIndices.Add(edge5.vertex1Index, edge5.vertex1Index);
                }
                if (!this.m_NonInternalVertexIndices.ContainsKey(edge5.vertex2Index))
                {
                    this.m_NonInternalVertexIndices.Add(edge5.vertex2Index, edge5.vertex2Index);
                }
            }
            for (int j = activeDecalProjector.DecalsMeshLowerVertexIndex; j <= activeDecalProjector.DecalsMeshUpperVertexIndex; j++)
            {
                if (!this.m_NonInternalVertexIndices.ContainsKey(j))
                {
                    this.m_ObsoleteInternalVertexIndices.Add(j);
                }
            }
            int num6 = 0;

            while (num6 < list.Count)
            {
                OptimizeEdge edge6 = list[num6];
                int          num7  = num6 + 1;
                while (true)
                {
                    if (num7 >= this.m_RedundantExternalEdges.Count)
                    {
                        num6++;
                        break;
                    }
                    OptimizeEdge edge7 = list[num7];
                    if ((edge6.vertex1Index != edge7.vertex1Index) && (edge6.vertex1Index != edge7.vertex2Index))
                    {
                        if ((((edge6.vertex2Index == edge7.vertex1Index) || (edge6.vertex2Index == edge7.vertex2Index)) && !this.m_ObsoleteExternalVertexIndices.Contains(edge6.vertex2Index)) && AreEdgesParallelOrIsAtLeastOneAPoint(a_DecalsMesh, edge6, edge7))
                        {
                            this.m_ObsoleteExternalVertexIndices.Add(edge6.vertex2Index);
                        }
                    }
                    else if (!this.m_ObsoleteExternalVertexIndices.Contains(edge6.vertex1Index) && AreEdgesParallelOrIsAtLeastOneAPoint(a_DecalsMesh, edge6, edge7))
                    {
                        this.m_ObsoleteExternalVertexIndices.Add(edge6.vertex1Index);
                    }
                    num7++;
                }
            }
            this.ClearTemporaryCollections();
        }
Ejemplo n.º 20
0
        private bool AreWeightedVertexPropertiesApproximatelyVertexProperties(DecalsMesh a_DecalsMesh, int a_VertexIndex)
        {
            bool   flag   = true;
            Decals decals = a_DecalsMesh.Decals;

            if (flag)
            {
                Vector3 vector = a_DecalsMesh.Vertices[a_VertexIndex];
                Vector3 zero   = Vector3.zero;
                int     num    = 0;
                while (true)
                {
                    if (num >= this.m_NeighboringVertexIndices.Count)
                    {
                        flag = flag && Vector3Extension.Approximately(vector, zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
                        break;
                    }
                    int     num2    = this.m_NeighboringVertexIndices[num];
                    float   num3    = this.m_NeighboringVertexWeight[num];
                    Vector3 vector3 = a_DecalsMesh.Vertices[num2];
                    zero += num3 * vector3;
                    num++;
                }
            }
            if (flag && (decals.CurrentNormalsMode == NormalsMode.Target))
            {
                Vector3 vector4 = a_DecalsMesh.Normals[a_VertexIndex];
                Vector3 zero    = Vector3.zero;
                int     num4    = 0;
                while (true)
                {
                    if (num4 >= this.m_NeighboringVertexIndices.Count)
                    {
                        flag = flag && Vector3Extension.Approximately(vector4, zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
                        break;
                    }
                    int     num5    = this.m_NeighboringVertexIndices[num4];
                    float   num6    = this.m_NeighboringVertexWeight[num4];
                    Vector3 vector6 = a_DecalsMesh.Normals[num5];
                    (zero + (num6 * vector6)).Normalize();
                    num4++;
                }
            }
            if (flag && (decals.CurrentTangentsMode == TangentsMode.Target))
            {
                Vector4 vector7 = a_DecalsMesh.Tangents[a_VertexIndex];
                Vector4 zero    = Vector3.zero;
                int     num7    = 0;
                while (true)
                {
                    if (num7 >= this.m_NeighboringVertexIndices.Count)
                    {
                        flag = flag && Vector4Extension.Approximately(vector7, zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
                        break;
                    }
                    int     num8    = this.m_NeighboringVertexIndices[num7];
                    float   num9    = this.m_NeighboringVertexWeight[num7];
                    Vector4 vector9 = a_DecalsMesh.Tangents[num8];
                    (zero + (num9 * vector9)).Normalize();
                    num7++;
                }
            }
            if (flag && ((decals.CurrentUVMode == UVMode.TargetUV) || (decals.CurrentUVMode == UVMode.TargetUV2)))
            {
                Vector2 vector10 = a_DecalsMesh.UVs[a_VertexIndex];
                Vector2 zero     = Vector3.zero;
                int     num10    = 0;
                while (true)
                {
                    if (num10 >= this.m_NeighboringVertexIndices.Count)
                    {
                        flag = flag && Vector2Extension.Approximately(vector10, zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
                        break;
                    }
                    int     num11    = this.m_NeighboringVertexIndices[num10];
                    float   num12    = this.m_NeighboringVertexWeight[num10];
                    Vector2 vector12 = a_DecalsMesh.UVs[num11];
                    zero += num12 * vector12;
                    num10++;
                }
            }
            if (flag && ((decals.CurrentUV2Mode == UV2Mode.TargetUV) || (decals.CurrentUV2Mode == UV2Mode.TargetUV2)))
            {
                Vector2 vector13 = a_DecalsMesh.UV2s[a_VertexIndex];
                Vector2 zero     = Vector3.zero;
                int     num13    = 0;
                while (true)
                {
                    if (num13 >= this.m_NeighboringVertexIndices.Count)
                    {
                        flag = flag && Vector2Extension.Approximately(vector13, zero, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError);
                        break;
                    }
                    int     num14    = this.m_NeighboringVertexIndices[num13];
                    float   num15    = this.m_NeighboringVertexWeight[num13];
                    Vector2 vector15 = a_DecalsMesh.UV2s[num14];
                    zero += num15 * vector15;
                    num13++;
                }
            }
            return(true);
        }
Ejemplo n.º 21
0
        private bool IsVertexObsolete(DecalsMesh a_DecalsMesh, int a_VertexIndex)
        {
            bool flag = false;

            if (this.m_NeighboringTriangles.Count <= 0)
            {
                return(flag);
            }
            else
            {
                flag = true;
                bool    flag2 = false;
                Vector3 zero  = Vector3.zero;
                foreach (int num in this.m_NeighboringTriangles)
                {
                    zero = this.m_TriangleNormals[num];
                    if (zero != Vector3.zero)
                    {
                        flag2 = true;
                        break;
                    }
                }
                if (flag2)
                {
                    foreach (int num2 in this.m_NeighboringTriangles)
                    {
                        Vector3 rhs = this.m_TriangleNormals[num2];
                        if ((rhs != Vector3.zero) && !MathfExtension.Approximately(Vector3.Dot(zero, rhs), 1f, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError))
                        {
                            flag = false;
                            break;
                        }
                    }
                }
                if (!flag)
                {
                    return(flag);
                }
                else
                {
                    float num4 = 0f;
                    int   num5 = 0;
                    while (true)
                    {
                        if (num5 >= this.m_NeighboringVertexIndices.Count)
                        {
                            float num7 = 0f;
                            if (!MathfExtension.Approximately(num4, 0f, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError))
                            {
                                num7 = 1f / num4;
                            }
                            for (int i = 0; i < this.m_NeighboringVertexIndices.Count; i++)
                            {
                                float num9 = this.m_NeighboringVertexDistances[i];
                                if (!MathfExtension.Approximately(num9, 0f, DecalsMeshMinimizer.s_CurrentMaximumAbsoluteError, DecalsMeshMinimizer.s_CurrentMaximumRelativeError))
                                {
                                    float item = 1f - (num9 / num7);
                                    this.m_NeighboringVertexWeight.Add(item);
                                }
                                else
                                {
                                    this.m_NeighboringVertexWeight.Add(0f);
                                    int num10 = this.m_NeighboringVertexIndices[i];
                                    flag = this.AreVertexPropertiesIdentical(a_DecalsMesh, a_VertexIndex, num10);
                                    if (!flag)
                                    {
                                        break;
                                    }
                                }
                            }
                            break;
                        }
                        float num6 = this.m_NeighboringVertexDistances[num5];
                        num4 += num6;
                        num5++;
                    }
                }
            }
            if (flag)
            {
                flag = this.AreWeightedVertexPropertiesApproximatelyVertexProperties(a_DecalsMesh, a_VertexIndex);
            }
            return(flag);
        }
Ejemplo n.º 22
0
 public bool IsExternalVertexObsolete(DecalsMesh a_DecalsMesh, int a_VertexIndex)
 {
     this.ClearAll();
     this.ComputeNeighbors(a_DecalsMesh, a_VertexIndex);
     return(this.IsVertexObsolete(a_DecalsMesh, a_VertexIndex));
 }
Ejemplo n.º 23
0
 private void InitializeSortedNeighboringExternalVertices(DecalsMesh a_DecalsMesh, int a_VertexIndex)
 {
     this.m_SortedNeighboringVerticesInitialized = true;
     this.m_UnusedNeighboringTriangles.AddRange(this.m_NeighboringTriangles);
     if (this.m_UnusedNeighboringTriangles.Count > 0)
     {
         int num  = this.m_UnusedNeighboringTriangles[this.m_UnusedNeighboringTriangles.Count - 1];
         int num2 = this.InnerTriangleIndexOfVertexIndex(a_DecalsMesh, num, a_VertexIndex);
         num2 = this.SuccessorInnerTriangleVertexIndex(num2);
         this.m_SortedNeighboringVertices.Add(a_DecalsMesh.Triangles[num + num2]);
         this.m_SortedNeighboringVertices.Add(a_DecalsMesh.Triangles[num + this.SuccessorInnerTriangleVertexIndex(num2)]);
         this.m_UnusedNeighboringTriangles.RemoveAt(this.m_UnusedNeighboringTriangles.Count - 1);
     }
     else
     {
         this.m_SortedNeighboringVerticesInitialized = false;
         return;
     }
     while (true)
     {
         while (true)
         {
             if (this.m_UnusedNeighboringTriangles.Count != 0)
             {
                 bool flag  = false;
                 int  num3  = this.m_SortedNeighboringVertices[0];
                 int  num4  = this.m_SortedNeighboringVertices[this.m_SortedNeighboringVertices.Count - 1];
                 int  index = 0;
                 while (true)
                 {
                     if (index < this.m_UnusedNeighboringTriangles.Count)
                     {
                         int num6 = this.m_UnusedNeighboringTriangles[index];
                         int num7 = this.InnerTriangleIndexOfVertexIndex(a_DecalsMesh, num6, a_VertexIndex);
                         num7 = this.SuccessorInnerTriangleVertexIndex(num7);
                         if (a_DecalsMesh.Triangles[num6 + num7] == num4)
                         {
                             int item = a_DecalsMesh.Triangles[num6 + this.SuccessorInnerTriangleVertexIndex(num7)];
                             this.m_SortedNeighboringVertices.Add(item);
                             this.m_UnusedNeighboringTriangles.RemoveAt(index);
                             flag = true;
                         }
                         else
                         {
                             int num10 = num7;
                             int num8  = a_DecalsMesh.Triangles[num6 + this.SuccessorInnerTriangleVertexIndex(num7)];
                             if (num8 != num3)
                             {
                                 index++;
                                 continue;
                             }
                             int item = a_DecalsMesh.Triangles[num6 + num10];
                             this.m_SortedNeighboringVertices.Insert(0, item);
                             this.m_UnusedNeighboringTriangles.RemoveAt(index);
                             flag = true;
                         }
                     }
                     if (flag)
                     {
                         continue;
                     }
                     else
                     {
                         this.m_SortedNeighboringVerticesInitialized = false;
                     }
                     break;
                 }
             }
             return;
         }
     }
 }