Added player character and step in/out of dialogue in scene 101

2026-08-15 15:22:47 +02:00
parent a42f25d5fa
commit 38ba2b0eff
2019 changed files with 181227 additions and 265 deletions
@@ -0,0 +1,138 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.ProBuilder;
+
+namespace UnityEngine.ProBuilder.MeshOperations
+{
+    /// <summary>
+    /// Provides methods for merging multiple faces of a <see cref="ProBuilderMesh"/> to a single face.
+    /// </summary>
+    public static class MergeElements
+    {
+        /// <summary>
+        /// Merges each pair of faces into a single face. Indexes are combined, but otherwise the properties of
+        /// the first face in the pair take precedence.
+        ///
+        /// This is the equivalent of the [Merge Faces](../manual/Face_Merge.html) action.
+        /// </summary>
+        /// <param name="target">The source mesh.</param>
+        /// <param name="pairs">The list of face pairs to merge.</param>
+        /// <param name="collapseCoincidentVertices">True to condense coincident vertex positions on each face.</param>
+        /// <returns>A list of the new faces created.</returns>
+        public static List<Face> MergePairs(ProBuilderMesh target, IEnumerable<SimpleTuple<Face, Face>> pairs, bool collapseCoincidentVertices = true)
+        {
+            HashSet<Face> remove = new HashSet<Face>();
+            List<Face> add = new List<Face>();
+
+            foreach (SimpleTuple<Face, Face> pair in pairs)
+            {
+                Face left = pair.item1;
+                Face right = pair.item2;
+                int leftLength = left.indexesInternal.Length;
+                int rightLength = right.indexesInternal.Length;
+                int[] indexes = new int[leftLength + rightLength];
+                System.Array.Copy(left.indexesInternal, 0, indexes, 0, leftLength);
+                System.Array.Copy(right.indexesInternal, 0, indexes, leftLength, rightLength);
+                add.Add(new Face(indexes,
+                        left.submeshIndex,
+                        left.uv,
+                        left.smoothingGroup,
+                        left.textureGroup,
+                        left.elementGroup,
+                        left.manualUV));
+                remove.Add(left);
+                remove.Add(right);
+            }
+
+            List<Face> faces = target.facesInternal.Where(x => !remove.Contains(x)).ToList();
+            faces.AddRange(add);
+            target.faces = faces;
+
+            if (collapseCoincidentVertices)
+                CollapseCoincidentVertices(target, add);
+
+            return add;
+        }
+
+        /// <summary>
+        /// Merges a collection of faces into a single face. This function does not
+        /// perform any sanity checks: it just merges faces, so the caller must make
+        /// sure that the input is valid. This method also removes duplicate vertices
+        /// created as a result of merging previously common vertices.
+        ///
+        /// This is the equivalent of the [Merge Faces](../manual/Face_Merge.html) action.
+        /// </summary>
+        /// <param name="target">The source mesh.</param>
+        /// <param name="faces">The collection of faces to move.</param>
+        /// <returns>The single merged Face.</returns>
+        public static Face Merge(ProBuilderMesh target, IEnumerable<Face> faces)
+        {
+            int mergedCount = faces != null ? faces.Count() : 0;
+
+            if (mergedCount < 1)
+                return null;
+
+            Face first = faces.First();
+
+            Face mergedFace = new Face(faces.SelectMany(x => x.indexesInternal).ToArray(),
+                    first.submeshIndex,
+                    first.uv,
+                    first.smoothingGroup,
+                    first.textureGroup,
+                    first.elementGroup,
+                    first.manualUV);
+
+            Face[] rebuiltFaces = new Face[target.facesInternal.Length - mergedCount + 1];
+
+            int n = 0;
+
+            HashSet<Face> skip = new HashSet<Face>(faces);
+
+            foreach (Face f in target.facesInternal)
+            {
+                if (!skip.Contains(f))
+                    rebuiltFaces[n++] = f;
+            }
+
+            rebuiltFaces[n] = mergedFace;
+
+            target.faces = rebuiltFaces;
+
+            CollapseCoincidentVertices(target, new Face[] { mergedFace });
+
+            return mergedFace;
+        }
+
+        /// <summary>
+        /// Condense co-incident vertex positions per-face. vertices must already be marked as shared in the sharedIndexes
+        /// array to be considered. This method is really only useful after merging faces.
+        /// </summary>
+        /// <param name="mesh"></param>
+        /// <param name="faces"></param>
+        internal static void CollapseCoincidentVertices(ProBuilderMesh mesh, IEnumerable<Face> faces)
+        {
+            Dictionary<int, int> lookup = mesh.sharedVertexLookup;
+            Dictionary<int, int> matches = new Dictionary<int, int>();
+
+            foreach (Face face in faces)
+            {
+                matches.Clear();
+
+                for (int i = 0; i < face.indexesInternal.Length; i++)
+                {
+                    int common = lookup[face.indexesInternal[i]];
+
+                    if (matches.ContainsKey(common))
+                        face.indexesInternal[i] = matches[common];
+                    else
+                        matches.Add(common, face.indexesInternal[i]);
+                }
+
+                face.InvalidateCache();
+            }
+
+            MeshValidation.RemoveUnusedVertices(mesh);
+        }
+    }
+}