@alpsckr/unitycli 0.4.0

package/extensions/probuilder/unitypkg/Editor/ProBuilder/ProBuilderAppendCompletionProof.cs

@@ -0,0 +1,254 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>AppendVerticesToEdge 的请求终态证明；planner 只操作托管 Vertex/Face 克隆，绝不读取或修改 effect mesh。</summary>
+    internal static class ProBuilderAppendCompletionProof
+    {
+        // PB 5.2.4 Smoothing 的 internal 范围常量；proof 必须保持同一分组判定但不能引用 internal API。
+        private const int SmoothingGroupNone = 0;
+        private const int SmoothRangeMax = 24;
+        private const int HardRangeMin = 42;
+
+        internal sealed class Plan
+        {
+            internal readonly CanonicalMeshSnapshot Before;
+            internal readonly Edge[] FrozenEdges;
+            internal readonly int Count;
+            internal readonly long InsertedCount;
+            internal readonly RawPlan[] Raw;
+            internal readonly FacePlan[] Faces;
+            internal readonly int[][] Shared;
+            internal readonly int[][] SharedTextures;
+            internal Plan(CanonicalMeshSnapshot before, Edge[] edges, int count, long insertedCount, IEnumerable<RawPlan> raw, IEnumerable<FacePlan> faces, IEnumerable<int[]> shared, IEnumerable<int[]> textures)
+            { Before = before; FrozenEdges = edges.Select(edge => new Edge(edge.a, edge.b)).ToArray(); Count = count; InsertedCount = insertedCount; Raw = raw.ToArray(); Faces = faces.ToArray(); Shared = shared.Select(value => value.ToArray()).ToArray(); SharedTextures = textures.Select(value => value.ToArray()).ToArray(); }
+        }
+
+        internal sealed class RawPlan
+        {
+            internal readonly Vector3 Position; internal CanonicalMeshSnapshot.ChannelValue Normal, Tangent; internal readonly CanonicalMeshSnapshot.ChannelValue Color; internal readonly CanonicalMeshSnapshot.ChannelValue[] Uvs;
+            internal RawPlan(Vertex vertex, CanonicalMeshSnapshot.RawVertex profile) { Position = vertex.position; Normal = Channel(profile.LocalNormal.IsPresent, vertex.normal); Tangent = Channel(profile.Tangent.IsPresent, vertex.tangent); Color = Channel(profile.Color.IsPresent, (Vector4)vertex.color); var uv = profile.Uvs; Uvs = new[] { Channel(uv[0].IsPresent, (Vector4)vertex.uv0), Channel(uv[1].IsPresent, (Vector4)vertex.uv2), Channel(uv[2].IsPresent, vertex.uv3), Channel(uv[3].IsPresent, vertex.uv4) }; }
+            internal RawPlan(CanonicalMeshSnapshot.RawVertex vertex) { Position = vertex.LocalPosition; Normal = vertex.LocalNormal; Tangent = vertex.Tangent; Color = vertex.Color; Uvs = vertex.Uvs; }
+        }
+
+        internal sealed class FacePlan
+        {
+            internal readonly CanonicalMeshSnapshot.FaceOccurrence Source; internal readonly int[] RawStream; internal readonly bool Rebuilt;
+            internal readonly CanonicalMeshSnapshot.MaterialClaim Material;
+            internal FacePlan(CanonicalMeshSnapshot.FaceOccurrence source, IEnumerable<int> raw, bool rebuilt = false, Material rebuiltMaterial = null)
+            { Source = source; RawStream = raw.ToArray(); Rebuilt = rebuilt; Material = rebuilt ? CanonicalMeshSnapshot.WithSerializedFaceMaterial(source.Material, rebuiltMaterial) : source.Material; }
+        }
+
+        /// <summary>effect 前冻结 target identity、typed edges、全部 canonical channels，并忠实模拟 5.2.4 append 的 terminal mesh。</summary>
+        internal static Plan TryCreate(GameObject target, ProBuilderMesh mesh, Edge[] requestedEdges, int count)
+        {
+            if (target == null || mesh == null || requestedEdges == null || requestedEdges.Length == 0 || count < 1 || count > 512) return null;
+            var frozenEdges = requestedEdges.Select(edge => new Edge(edge.a, edge.b)).ToArray();
+            var before = CanonicalMeshSnapshot.Capture(target);
+            var renderer = target.GetComponent<Renderer>();
+            if (before == null || !before.HasSharedTextures || !CanonicalMeshSnapshot.RefreshArithmeticFinite(before) || !MaterialSlotsStable(before, renderer) || !FrozenEdgesAreReadable(before, frozenEdges)) return null;
+            // sharedVertices 的原成员顺序决定 AppendElements localEdge 端点；必须从 live group 冻结首 raw。
+            var firstRaw = FreezeFirstRaw(mesh, before);
+            if (firstRaw == null) return null;
+
+            // Dictionary insertion order follows frozen edge then exact neighbor-face order; overlapping faces would require mutable loop state, so reject before effect.
+            var selected = frozenEdges.Select(edge => SharedEdge(before, edge)).ToArray();
+            if (selected.Any(edge => edge == null) || selected.Distinct().Count() != selected.Length) return null;
+            var affected = selected.SelectMany(edge => NeighborFaces(before, edge.Item1, edge.Item2)).ToArray();
+            if (affected.Length == 0 || affected.Distinct().Count() != affected.Length || !FacesHaveExclusiveRawOwnership(before, affected)) return null;
+            var insertedCount = (long)frozenEdges.Length * count;
+            var workingRawCount = (long)before.RawVertices.Length + affected.Sum(face => (long)face.Boundary.Length + count);
+            if (insertedCount <= 0L || insertedCount > int.MaxValue - (long)before.RawVertices.Length || workingRawCount > int.MaxValue) return null;
+
+            try
+            {
+                var rebuiltMaterial = BuiltinMaterials.defaultMaterial;
+                if (rebuiltMaterial == null) return null;
+                var deleted = new HashSet<int>(affected.SelectMany(face => face.DirectedRawTriangleStream).Distinct());
+                var raw = before.RawVertices.Where(vertex => !deleted.Contains(vertex.RawIndex)).Select(vertex => new RawPlan(vertex)).ToList();
+                // lookup handle 是 raw-index keyed Dictionary；保留空 slot 直至所有 AddShared 完成，不能压缩旧 handle。
+                var shared = before.SharedVertices.Select(group => group.MemberRawIndexes.Where(index => !deleted.Contains(index)).Select(index => Remap(index, deleted)).ToList()).ToList();
+                var textures = before.SharedTextures.Select(group => group.MemberRawIndexes.Where(index => !deleted.Contains(index)).Select(index => Remap(index, deleted)).ToArray()).Where(group => group.Length > 0).ToList();
+                var modified = new Dictionary<int, FacePlan>();
+
+                // 5.2.4 Dictionary insertion/raw append 顺序是 frozen common-edge order 再 GetNeighborFaces order，不是 face occurrence order。
+                foreach (var face in affected)
+                {
+                    var edge = selected.Single(value => NeighborFaces(before, value.Item1, value.Item2).Contains(face));
+                    var ordered = OrderedFaceVertices(before, face);
+                    var edgePosition = FindBoundaryPosition(before, ordered.RawIndexes, edge.Item1, edge.Item2);
+                    if (edgePosition < 0) return null;
+                    var profile = before.RawVertices[0];
+                    var inserted = MixedVertices(before, firstRaw, edge.Item1, edge.Item2, count);
+                    if (inserted.Any(vertex => !FiniteForProfile(vertex, profile))) return null;
+                    var insertedHandles = Enumerable.Range(0, count).Select(index => before.RawVertices.Length + selected.ToList().IndexOf(edge) * count + index).ToArray();
+                    if (ordered.Forward(edgePosition, edge.Item1, edge.Item2)) { ordered.Insert(edgePosition + 1, inserted, insertedHandles); }
+                    else { ordered.Insert(edgePosition + 1, inserted.Reverse<Vertex>(), insertedHandles.Reverse()); }
+
+                    var relative = TriangulateExact(ordered.Vertices);
+                    if (relative == null) return null;
+                    var offset = raw.Count;
+                    raw.AddRange(ordered.Vertices.Select(vertex => new RawPlan(vertex, profile)));
+                    for (var index = 0; index < ordered.Handles.Count; index++) AddShared(shared, ordered.Handles[index], offset + index);
+                    modified.Add(face.OccurrenceIndex, new FacePlan(face, relative.Select(index => offset + index), true, rebuiltMaterial));
+                }
+
+                // face array 保留原 occurrence 顺序；仅 raw append 使用 modifiedFaces insertion 顺序。
+                var orderedFaces = before.Faces.Select(face => modified.TryGetValue(face.OccurrenceIndex, out var replacement) ? replacement : new FacePlan(face, face.DirectedRawTriangleStream.Select(index => Remap(index, deleted)))).ToArray();
+                var terminalShared = shared.Where(group => group.Count > 0).Select(group => group.ToArray()).ToArray();
+                // ProBuilderMeshFunction.ToMesh 无条件清空 mesh.uv2；canonical UV1 从 MeshFilter.sharedMesh.uv2 读取。
+                foreach (var vertex in raw) vertex.Uvs[1] = new CanonicalMeshSnapshot.ChannelValue(false, Vector4.zero);
+                var positions = raw.Select(vertex => vertex.Position).ToArray();
+                var streams = orderedFaces.Select(face => face.RawStream).ToArray();
+                // 5.2.4 会把跨面的插入顶点共享给不同 UV 岛；tangent 中间倒数可非有限，但最终归一化结果仍确定且有限。
+                // CalculateDerivedChannels 逐句重放该终态并验证最终 normal/tangent，不能再用通用中间有限性门禁拒绝合法 Cube edge。
+                if (!CanonicalMeshSnapshot.TerminalTopologyReadable(positions, streams, terminalShared)
+                    || !CalculateDerivedChannels(raw, orderedFaces, terminalShared)) return null;
+                return new Plan(before, frozenEdges, count, insertedCount, raw, orderedFaces, terminalShared, textures);
+            }
+            catch { return null; }
+        }
+
+        /// <summary>effect 后必须从 effect 前 identity fresh-resolve，并对全部 operation-owned terminal channels 作精确比较。</summary>
+        internal static bool Matches(Plan plan, string target)
+        {
+            if (plan == null) return false;
+            var freshMesh = CanonicalMeshSnapshot.ResolveFreshMesh(target, plan.Before.Identity);
+            var after = freshMesh == null ? null : CanonicalMeshSnapshot.Capture(freshMesh.gameObject);
+            if (after == null || !IdentityAndTransformEqual(plan.Before, after) || after.RawVertices.Length != plan.Raw.Length || after.Faces.Length != plan.Faces.Length || after.HasSharedTextures != true) return false;
+            for (var index = 0; index < plan.Raw.Length; index++) if (!RawBaseEquals(after.RawVertices[index], plan.Raw[index])) return false;
+            for (var index = 0; index < plan.Faces.Length; index++) if (!FaceEquals(after.Faces[index], plan.Faces[index])) return false;
+            if (!OrderedPartitionsEqual(after.SharedVertices.Select(group => group.MemberRawIndexes), plan.Shared) || !OrderedPartitionsEqual(after.SharedTextures.Select(group => group.MemberRawIndexes), plan.SharedTextures)) return false;
+            // positions/faces/attrs/shared/UV0 已先完整证明，derived replay 才消费最终 normal/tangent。
+            return plan.Raw.Select((expected, index) => CanonicalMeshSnapshot.ChannelValueEquals(after.RawVertices[index].LocalNormal, expected.Normal) && CanonicalMeshSnapshot.ChannelValueEquals(after.RawVertices[index].Tangent, expected.Tangent)).All(value => value);
+        }
+
+        private sealed class OrderedFace
+        {
+            internal readonly List<Vertex> Vertices; internal readonly List<int> RawIndexes; internal readonly List<int> Handles;
+            internal OrderedFace(IEnumerable<Vertex> vertices, IEnumerable<int> raw, IEnumerable<int> handles) { Vertices = vertices.ToList(); RawIndexes = raw.ToList(); Handles = handles.ToList(); }
+            internal bool Forward(int index, int a, int b) => Handles[index] == a && Handles[(index + 1) % Handles.Count] == b;
+            internal void Insert(int index, IEnumerable<Vertex> vertices, IEnumerable<int> handles) { var values = vertices.ToArray(); Vertices.InsertRange(index, values); RawIndexes.InsertRange(index, Enumerable.Repeat(-1, values.Length)); Handles.InsertRange(index, handles); }
+        }
+
+        // 通过 package-internal exact helper 获取外围循环；reflection 的输入是新建 Face，不访问真实 mesh。
+        private static OrderedFace OrderedFaceVertices(CanonicalMeshSnapshot before, CanonicalMeshSnapshot.FaceOccurrence face)
+        {
+            var clone = new Face(face.DirectedRawTriangleStream);
+            var type = typeof(Face).Assembly.GetType("UnityEngine.ProBuilder.WingedEdge");
+            var method = type?.GetMethod("SortEdgesByAdjacency", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(Face) }, null);
+            var edges = method?.Invoke(null, new object[] { clone }) as IEnumerable;
+            if (edges == null) return null;
+            var raw = edges.Cast<Edge>().Select(edge => edge.a).ToArray();
+            return raw.Length < 3 || raw.Distinct().Count() != raw.Length ? null : new OrderedFace(raw.Select(index => ToVertex(before.RawVertices[index])), raw, raw.Select(index => before.RawVertices[index].SharedHandle));
+        }
+
+        // 通过 package-internal exact helper 三角化克隆的 managed Vertex 列表；失败即 effect 前拒绝。
+        private static List<int> TriangulateExact(List<Vertex> vertices)
+        {
+            var type = typeof(Face).Assembly.GetType("UnityEngine.ProBuilder.MeshOperations.Triangulation");
+            var method = type?.GetMethod("TriangulateVertices", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null,
+                new[] { typeof(IList<Vertex>), typeof(List<int>).MakeByRefType(), typeof(bool), typeof(bool) }, null);
+            var args = new object[] { vertices.Select(vertex => new Vertex(vertex)).ToList(), null, false, false };
+            return method != null && (bool)method.Invoke(null, args) && args[1] is List<int> result ? result : null;
+        }
+
+        private static bool FrozenEdgesAreReadable(CanonicalMeshSnapshot before, IEnumerable<Edge> edges) => edges.All(edge => edge.a >= 0 && edge.b >= 0 && edge.a < before.RawVertices.Length && edge.b < before.RawVertices.Length && edge.a != edge.b);
+        /// <summary>ToMesh 会删除空 submesh 并重排 material slots；仅接受每个 slot 都有原始 face 精确引用的稳定布局。</summary>
+        private static bool MaterialSlotsStable(CanonicalMeshSnapshot before, Renderer renderer)
+        {
+            var materials = renderer == null ? null : renderer.sharedMaterials;
+            return before != null && materials != null && materials.Length > 0
+                && before.Faces.All(face => face.SubmeshIndex >= 0 && face.SubmeshIndex < materials.Length)
+                && Enumerable.Range(0, materials.Length).All(slot => before.Faces.Any(face => face.SubmeshIndex == slot));
+        }
+        private static Tuple<int, int> SharedEdge(CanonicalMeshSnapshot before, Edge edge) { var a = before.RawVertices[edge.a].SharedHandle; var b = before.RawVertices[edge.b].SharedHandle; return Tuple.Create(a, b); }
+        private static CanonicalMeshSnapshot.FaceOccurrence[] NeighborFaces(CanonicalMeshSnapshot before, int a, int b) => before.Faces.Where(face => face.Boundary.Any(edge => (edge.SharedA == a && edge.SharedB == b) || (edge.SharedA == b && edge.SharedB == a))).ToArray();
+        private static bool FacesHaveExclusiveRawOwnership(CanonicalMeshSnapshot before, IEnumerable<CanonicalMeshSnapshot.FaceOccurrence> faces)
+        {
+            if (before == null || faces == null) return false;
+            var affected = faces.ToArray();
+            var occurrences = new HashSet<int>(affected.Select(face => face.OccurrenceIndex));
+            var perFace = affected.Select(face => face.DirectedRawTriangleStream.Distinct().ToArray()).ToArray();
+            var deleted = new HashSet<int>(perFace.SelectMany(raw => raw));
+            return deleted.Count == perFace.Sum(raw => raw.Length)
+                && before.Faces.Where(face => !occurrences.Contains(face.OccurrenceIndex)).All(face => face.DirectedRawTriangleStream.All(raw => !deleted.Contains(raw)));
+        }
+        private static int FindBoundaryPosition(CanonicalMeshSnapshot before, List<int> raw, int a, int b) { for (var index = 0; index < raw.Count; index++) { var x = before.RawVertices[raw[index]].SharedHandle; var y = before.RawVertices[raw[(index + 1) % raw.Count]].SharedHandle; if ((x == a && y == b) || (x == b && y == a)) return index; } return -1; }
+        private static int[] FreezeFirstRaw(ProBuilderMesh mesh, CanonicalMeshSnapshot before) { var groups = mesh.sharedVertices; if (groups == null || groups.Count != before.SharedVertices.Length) return null; var first = new int[groups.Count]; for (var handle = 0; handle < groups.Count; handle++) { if (groups[handle] == null || groups[handle].Count == 0) return null; first[handle] = groups[handle][0]; if (!before.SharedVertices[handle].MemberRawIndexes.Contains(first[handle])) return null; } return first; }
+        private static List<Vertex> MixedVertices(CanonicalMeshSnapshot before, int[] firstRaw, int a, int b, int count) { var x = ToVertex(before.RawVertices[firstRaw[a]]); var y = ToVertex(before.RawVertices[firstRaw[b]]); return Enumerable.Range(0, count).Select(index => Vertex.Mix(x, y, (index + 1) / ((float)count + 1))).ToList(); }
+        private static Vertex ToVertex(CanonicalMeshSnapshot.RawVertex raw) { var vertex = new Vertex { position = raw.LocalPosition }; Set(vertex, raw.LocalNormal, MeshArrays.Normal, value => vertex.normal = (Vector3)value); Set(vertex, raw.Tangent, MeshArrays.Tangent, value => vertex.tangent = value); Set(vertex, raw.Color, MeshArrays.Color, value => vertex.color = (Color)value); var uv = raw.Uvs; Set(vertex, uv[0], MeshArrays.Texture0, value => vertex.uv0 = (Vector2)value); Set(vertex, uv[1], MeshArrays.Texture1, value => vertex.uv2 = (Vector2)value); Set(vertex, uv[2], MeshArrays.Texture2, value => vertex.uv3 = value); Set(vertex, uv[3], MeshArrays.Texture3, value => vertex.uv4 = value); return vertex; }
+        private static void Set(Vertex vertex, CanonicalMeshSnapshot.ChannelValue value, MeshArrays attribute, Action<Vector4> set) { if (value.IsPresent) set(value.Value); }
+        private static CanonicalMeshSnapshot.ChannelValue Channel(bool present, Vector4 value) => new CanonicalMeshSnapshot.ChannelValue(present, value);
+        private static bool FiniteForProfile(Vertex vertex, CanonicalMeshSnapshot.RawVertex profile)
+        {
+            if (vertex == null || profile == null || !Finite(vertex.position)) return false;
+            var uv = profile.Uvs;
+            return (!profile.LocalNormal.IsPresent || Finite(vertex.normal)) && (!profile.Tangent.IsPresent || Finite(vertex.tangent))
+                && (!profile.Color.IsPresent || Finite((Vector4)vertex.color)) && (!uv[0].IsPresent || Finite((Vector4)vertex.uv0))
+                && (!uv[1].IsPresent || Finite((Vector4)vertex.uv2)) && (!uv[2].IsPresent || Finite(vertex.uv3)) && (!uv[3].IsPresent || Finite(vertex.uv4));
+        }
+        private static void AddShared(List<List<int>> shared, int handle, int raw) { while (shared.Count <= handle) shared.Add(new List<int>()); shared[handle].Add(raw); }
+        private static int Remap(int raw, HashSet<int> deleted) => raw - deleted.Count(index => index < raw);
+        private static bool IdentityAndTransformEqual(CanonicalMeshSnapshot before, CanonicalMeshSnapshot after) => CanonicalMeshSnapshot.IdentityAndTransformEqual(before, after);
+        private static bool RawBaseEquals(CanonicalMeshSnapshot.RawVertex actual, RawPlan expected) => CanonicalMeshSnapshot.ExactEquals(actual.LocalPosition, expected.Position) && CanonicalMeshSnapshot.ChannelValueEquals(actual.Color, expected.Color) && actual.Uvs.Zip(expected.Uvs, CanonicalMeshSnapshot.ChannelValueEquals).All(value => value);
+        private static bool FaceEquals(CanonicalMeshSnapshot.FaceOccurrence actual, FacePlan expected) => actual.SubmeshIndex == expected.Source.SubmeshIndex && (!expected.Rebuilt ? actual.SmoothingGroup == expected.Source.SmoothingGroup && actual.TextureGroup == expected.Source.TextureGroup && actual.ElementGroup == expected.Source.ElementGroup && actual.ManualUv == expected.Source.ManualUv && CanonicalMeshSnapshot.UvValueEquals(actual.Uv, expected.Source.Uv) : actual.SmoothingGroup == 0 && actual.TextureGroup == -1 && actual.ElementGroup == 0 && !actual.ManualUv && CanonicalMeshSnapshot.UvValueEquals(actual.Uv, AutoUnwrapSettings.tile)) && CanonicalMeshSnapshot.MaterialValueEquals(actual.Material, expected.Material) && actual.DirectedRawTriangleStream.SequenceEqual(expected.RawStream);
+        /// <summary>逐句重放 5.2.4 CalculateHardNormals、shared smoothing pass 和 CalculateTangents；只使用 terminal managed plan。</summary>
+        private static bool CalculateDerivedChannels(IList<RawPlan> raw, IList<FacePlan> faces, IEnumerable<int[]> shared)
+        {
+            var count = raw.Count; var normals = new Vector3[count]; var occurrences = new int[count];
+            foreach (var face in faces) for (var tri = 0; tri < face.RawStream.Length; tri += 3)
+            {
+                var a = face.RawStream[tri]; var b = face.RawStream[tri + 1]; var c = face.RawStream[tri + 2];
+                var cross = UnityEngine.ProBuilder.Math.Normal(raw[a].Position, raw[b].Position, raw[c].Position); cross.Normalize();
+                normals[a] += cross; normals[b] += cross; normals[c] += cross; occurrences[a]++; occurrences[b]++; occurrences[c]++;
+            }
+            for (var index = 0; index < count; index++) normals[index] /= occurrences[index];
+            var smoothing = new int[count]; var smoothGroupMax = SmoothRangeMax;
+            foreach (var face in faces)
+            {
+                foreach (var index in face.RawStream.Distinct()) { smoothing[index] = face.Rebuilt ? 0 : face.Source.SmoothingGroup; if (smoothing[index] >= smoothGroupMax) smoothGroupMax = smoothing[index] + 1; }
+            }
+            foreach (var members in shared)
+            {
+                var sums = new Vector3[smoothGroupMax]; var groupCounts = new float[smoothGroupMax];
+                foreach (var index in members) { var group = smoothing[index]; if (group <= SmoothingGroupNone || (group > SmoothRangeMax && group < HardRangeMin)) continue; sums[group] += normals[index]; groupCounts[group] += 1f; }
+                foreach (var index in members) { var group = smoothing[index]; if (group <= SmoothingGroupNone || (group > SmoothRangeMax && group < HardRangeMin)) continue; normals[index] = EnsureUnitVector(sums[group] / groupCounts[group]); }
+            }
+            for (var index = 0; index < count; index++) raw[index].Normal = new CanonicalMeshSnapshot.ChannelValue(true, normals[index]);
+            // CalculateTangents creates tangent storage before the position/UV0 early-return path.
+            if (raw.Any(vertex => !vertex.Uvs[0].IsPresent)) { for (var index = 0; index < count; index++) raw[index].Tangent = new CanonicalMeshSnapshot.ChannelValue(true, Vector4.zero); return Finite(raw); }
+            var tan1 = new Vector3[count]; var tan2 = new Vector3[count];
+            foreach (var face in faces) for (var tri = 0; tri < face.RawStream.Length; tri += 3)
+            {
+                var i1 = face.RawStream[tri]; var i2 = face.RawStream[tri + 1]; var i3 = face.RawStream[tri + 2]; var v1 = raw[i1].Position; var v2 = raw[i2].Position; var v3 = raw[i3].Position; var w1 = raw[i1].Uvs[0].Value; var w2 = raw[i2].Uvs[0].Value; var w3 = raw[i3].Uvs[0].Value;
+                var x1 = v2.x-v1.x; var x2 = v3.x-v1.x; var y1 = v2.y-v1.y; var y2 = v3.y-v1.y; var z1 = v2.z-v1.z; var z2 = v3.z-v1.z; var s1 = w2.x-w1.x; var s2 = w3.x-w1.x; var t1 = w2.y-w1.y; var t2 = w3.y-w1.y; var r = 1.0f/(s1*t2-s2*t1);
+                var sdir = new Vector3((t2*x1-t1*x2)*r,(t2*y1-t1*y2)*r,(t2*z1-t1*z2)*r); var tdir = new Vector3((s1*x2-s2*x1)*r,(s1*y2-s2*y1)*r,(s1*z2-s2*z1)*r);
+                tan1[i1]+=sdir; tan1[i2]+=sdir; tan1[i3]+=sdir; tan2[i1]+=tdir; tan2[i2]+=tdir; tan2[i3]+=tdir;
+            }
+            for (var index = 0; index < count; index++) { var n = normals[index]; var t = EnsureUnitVector(tan1[index]); Vector3.OrthoNormalize(ref n, ref t); raw[index].Tangent = new CanonicalMeshSnapshot.ChannelValue(true, new Vector4(t.x,t.y,t.z,Vector3.Dot(Vector3.Cross(n,t),tan2[index]) < 0f ? -1f : 1f)); }
+            return Finite(raw);
+        }
+        private static Vector3 EnsureUnitVector(Vector3 v) => Mathf.Abs(v.sqrMagnitude) < float.Epsilon ? Vector3.up : v.normalized;
+        private static bool Finite(IEnumerable<RawPlan> raw) => raw.All(vertex => Finite(vertex.Normal.Value.x) && Finite(vertex.Normal.Value.y) && Finite(vertex.Normal.Value.z) && Finite(vertex.Tangent.Value.x) && Finite(vertex.Tangent.Value.y) && Finite(vertex.Tangent.Value.z) && Finite(vertex.Tangent.Value.w));
+        private static bool Finite(float value) => !float.IsNaN(value) && !float.IsInfinity(value);
+        private static bool Finite(Vector3 value) => Finite(value.x) && Finite(value.y) && Finite(value.z);
+        private static bool Finite(Vector4 value) => Finite(value.x) && Finite(value.y) && Finite(value.z) && Finite(value.w);
+        /// <summary>Append 后的 group 与 member 顺序会决定后续 first-member 语义，必须逐层精确比较。</summary>
+        private static bool OrderedPartitionsEqual(IEnumerable<IEnumerable<int>> actual, IEnumerable<IEnumerable<int>> expected)
+        {
+            if (actual == null || expected == null) return false;
+            var left = actual.Select(group => group == null ? null : group.ToArray()).ToArray();
+            var right = expected.Select(group => group == null ? null : group.ToArray()).ToArray();
+            return left.Length == right.Length && left.Select((group, index) => group != null && right[index] != null && group.SequenceEqual(right[index])).All(value => value);
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/ProBuilderAtomicReadback.cs

@@ -0,0 +1,293 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>普通属性、变换和拓扑 Tool 的最小业务读回；不捕获完整 canonical 状态。</summary>
+    internal static class ProBuilderAtomicReadback
+    {
+        private const float Epsilon = 0.0001f;
+
+        internal sealed class SourceMeshGeometry
+        {
+            internal Vector3[] Vertices;
+            internal int[] Triangles;
+        }
+
+        internal sealed class ScaleBakeClaim
+        {
+            internal Vector3 LocalPosition;
+            internal Quaternion LocalRotation;
+            internal Vector3[] ExpectedLocalPositions;
+            internal Vector3[] ExpectedWorldPositions;
+        }
+
+        internal sealed class SplitVertexClaim
+        {
+            internal int[] Requested;
+            internal Vector3[] Positions;
+            internal bool HasObservableEffect;
+        }
+
+        /// <summary>读取 raw local positions，调用方必须将返回值视为不可变快照。</summary>
+        internal static List<Vector3> CapturePositions(object mesh)
+        {
+            var positions = ProBuilderReflection.GetPositions(mesh);
+            return positions == null ? null : new List<Vector3>(positions);
+        }
+
+        /// <summary>冻结 FreezeScaleTransform 的最小业务终态：local scale 烘焙、局部姿态不变且世界几何不变。</summary>
+        internal static ScaleBakeClaim CaptureScaleBake(GameObject go, object mesh)
+        {
+            var positions = CapturePositions(mesh);
+            if (go == null || positions == null || positions.Count == 0 || !Finite(go.transform.localScale)) return null;
+            var expectedLocal = positions.Select(value => Vector3.Scale(value, go.transform.localScale)).ToArray();
+            var expectedWorld = positions.Select(go.transform.TransformPoint).ToArray();
+            if (expectedLocal.Any(value => !Finite(value)) || expectedWorld.Any(value => !Finite(value))) return null;
+            return new ScaleBakeClaim
+            {
+                LocalPosition = go.transform.localPosition,
+                LocalRotation = go.transform.localRotation,
+                ExpectedLocalPositions = expectedLocal,
+                ExpectedWorldPositions = expectedWorld
+            };
+        }
+
+        /// <summary>验证 FreezeScaleTransform 的 fresh typed readback，不比较无关 mesh channel。</summary>
+        internal static bool ScaleWasBaked(GameObject go, object mesh, ScaleBakeClaim claim)
+        {
+            var after = CapturePositions(mesh);
+            if (go == null || claim == null || after == null || claim.ExpectedLocalPositions == null || claim.ExpectedWorldPositions == null
+                || after.Count != claim.ExpectedLocalPositions.Length || after.Count != claim.ExpectedWorldPositions.Length
+                || !Approximately(go.transform.localScale, Vector3.one)
+                || go.transform.localPosition != claim.LocalPosition || go.transform.localRotation != claim.LocalRotation) return false;
+            for (var index = 0; index < after.Count; index++)
+                if (!Approximately(after[index], claim.ExpectedLocalPositions[index])
+                    || !Approximately(go.transform.TransformPoint(after[index]), claim.ExpectedWorldPositions[index])) return false;
+            return true;
+        }
+
+        /// <summary>冻结 split 请求对应的 raw indexes、positions 与是否存在可观察 shared partition 变化。</summary>
+        internal static SplitVertexClaim CaptureSplitVertexClaim(object mesh, int[] requested)
+        {
+            var pb = mesh as ProBuilderMesh;
+            var positions = CapturePositions(mesh);
+            if (pb == null || requested == null || requested.Length == 0 || positions == null || pb.sharedVertices == null) return null;
+            var groups = pb.sharedVertices.Select(value => value == null ? null : value.ToArray()).ToArray();
+            if (groups.Any(value => value == null) || requested.Any(index => index < 0 || index >= positions.Count)) return null;
+            var observable = false;
+            foreach (var raw in requested)
+            {
+                var owners = groups.Where(group => group.Contains(raw)).ToArray();
+                if (owners.Length != 1) return null;
+                if (owners[0].Length > 1) observable = true;
+            }
+            return new SplitVertexClaim { Requested = (int[])requested.Clone(), Positions = positions.ToArray(), HasObservableEffect = observable };
+        }
+
+        /// <summary>fresh shared partition 中每个请求 raw 必须成为 singleton，且 split 不得移动顶点。</summary>
+        internal static bool SplitVerticesMatch(object mesh, SplitVertexClaim claim)
+        {
+            var pb = mesh as ProBuilderMesh;
+            var positions = CapturePositions(mesh);
+            if (pb == null || claim == null || claim.Requested == null || claim.Positions == null || positions == null
+                || positions.Count != claim.Positions.Length || pb.sharedVertices == null) return false;
+            if (positions.Where((value, index) => !Approximately(value, claim.Positions[index])).Any()) return false;
+            var groups = pb.sharedVertices.Select(value => value == null ? null : value.ToArray()).ToArray();
+            return !groups.Any(value => value == null)
+                && claim.Requested.All(raw => groups.Count(group => group.Contains(raw)) == 1 && groups.Single(group => group.Contains(raw)).Length == 1);
+        }
+
+        /// <summary>为 ProBuilder scene mutation 登记真正持有 serialized mesh 状态的对象。</summary>
+        internal static void RegisterMeshUndo(GameObject go, object mesh, string name, bool includeTransform = false, params UnityEngine.Object[] additional)
+        {
+            var values = new List<UnityEngine.Object>();
+            if (go != null) values.Add(go);
+            if (includeTransform && go != null) values.Add(go.transform);
+            if (mesh is UnityEngine.Object meshObject) values.Add(meshObject);
+            var compiled = go == null ? null : go.GetComponent<MeshFilter>()?.sharedMesh;
+            if (compiled != null) values.Add(compiled);
+            if (additional != null) values.AddRange(additional.Where(value => value != null));
+            var unique = values.Where(value => value != null).Distinct().ToArray();
+            if (unique.Length > 0) Undo.RegisterCompleteObjectUndo(unique, name);
+        }
+
+        internal static SourceMeshGeometry CaptureSourceMeshGeometry(MeshFilter filter)
+        {
+            var source = filter == null ? null : filter.sharedMesh;
+            if (source == null || source.vertexCount < 1) return null;
+            var vertices = source.vertices;
+            var triangles = source.triangles;
+            if (vertices == null || triangles == null || triangles.Length < 3 || triangles.Length % 3 != 0
+                || vertices.Length != source.vertexCount || vertices.Any(value => !Finite(value))
+                || triangles.Any(index => index < 0 || index >= vertices.Length)) return null;
+            return new SourceMeshGeometry { Vertices = vertices, Triangles = triangles };
+        }
+
+        /// <summary>以有向 triangle 几何多重集验证 MeshImporter 结果，允许 importer 重排或复制 raw vertices。</summary>
+        internal static bool ConvertedGeometryMatchesSource(object mesh, SourceMeshGeometry source)
+        {
+            var positions = CapturePositions(mesh);
+            var faces = ProBuilderReflection.GetAllFaces(mesh);
+            if (source == null || positions == null || faces == null || positions.Count == 0) return false;
+            var expected = TriangleSignatures(source.Vertices, source.Triangles);
+            var actual = new List<string>();
+            foreach (var value in faces)
+            {
+                var indexes = (value as Face)?.indexes;
+                if (indexes == null || indexes.Count < 3 || indexes.Count % 3 != 0 || indexes.Any(index => index < 0 || index >= positions.Count)) return false;
+                for (var index = 0; index < indexes.Count; index += 3)
+                    actual.Add(TriangleSignature(positions[indexes[index]], positions[indexes[index + 1]], positions[indexes[index + 2]]));
+            }
+            actual.Sort(StringComparer.Ordinal);
+            return expected.SequenceEqual(actual);
+        }
+
+        /// <summary>验证输入 polygon、挤出距离与 Package 使用的 up-relative normal 方向。</summary>
+        internal static bool PolyShapeMatchesRequest(GameObject go, object mesh, IList<Vector3> points, float height, bool flipNormals)
+        {
+            var pb = mesh as ProBuilderMesh;
+            var positions = CapturePositions(mesh);
+            if (go == null || pb == null || points == null || points.Count < 3 || positions == null || !ReadableGeometry(mesh)
+                || points.Any(point => !positions.Any(value => Approximately(value, point)))) return false;
+            if (!Approximately(height, 0f) && !HasCommonExtrusionOffset(positions, points, Mathf.Abs(height))) return false;
+            if (pb.faces == null || pb.faces.Count == 0 || pb.faces[0] == null) return false;
+            var localNormal = UnityEngine.ProBuilder.Math.Normal(pb, pb.faces[0]);
+            if (!Finite(localNormal)) return false;
+            var dot = Vector3.Dot(go.transform.up, go.transform.TransformDirection(localNormal));
+            return flipNormals ? dot <= Epsilon : dot >= -Epsilon;
+        }
+
+        internal static bool SourcesWereRemovedAndGeometryIncluded(GameObject result, object mesh, int[] sourceIds, int minimumFaceCount)
+            => result != null && sourceIds != null && sourceIds.Length > 1 && sourceIds[0] == result.GetInstanceID()
+                && ReadableGeometry(mesh) && ProBuilderReflection.GetFaceCount(mesh) >= minimumFaceCount
+                && sourceIds.Skip(1).All(id => EditorUtility.InstanceIDToObject(id) == null);
+
+        internal static bool PolygonWasCreatedFromRequestedVertices(object mesh, int[] vertexIndices, int expectedFaceCount)
+        {
+            var faces = ProBuilderReflection.GetAllFaces(mesh);
+            if (faces == null || faces.Length != expectedFaceCount || vertexIndices == null) return false;
+            var indexes = (faces.GetValue(faces.Length - 1) as Face)?.indexes;
+            var requested = vertexIndices.Distinct().OrderBy(value => value).ToArray();
+            var actual = indexes?.Distinct().OrderBy(value => value).ToArray();
+            return actual != null && actual.SequenceEqual(requested);
+        }
+
+        internal static bool VerticesMovedByOffset(object mesh, IList<Vector3> before, int[] indices, Vector3 offset)
+        {
+            var after = CapturePositions(mesh);
+            return before != null && after != null && indices != null && indices.Length > 0
+                && indices.All(index => index >= 0 && index < before.Count && index < after.Count && Approximately(after[index], before[index] + offset));
+        }
+
+        internal static List<Vector3> CaptureWorldPositions(GameObject go, object mesh)
+        {
+            var positions = CapturePositions(mesh);
+            return go == null || positions == null ? null : positions.Select(go.transform.TransformPoint).ToList();
+        }
+
+        internal static bool PivotPreservesWorldGeometry(GameObject go, object mesh, Vector3 expectedPivot, IList<Vector3> worldPositions, bool requireBoundsCenter)
+        {
+            var positions = CapturePositions(mesh);
+            var renderer = go == null ? null : go.GetComponent<Renderer>();
+            return go != null && positions != null && worldPositions != null && positions.Count == worldPositions.Count
+                && Approximately(go.transform.position, expectedPivot)
+                && (!requireBoundsCenter || renderer != null && Approximately(renderer.bounds.center, expectedPivot))
+                && !positions.Where((value, index) => !Approximately(go.transform.TransformPoint(value), worldPositions[index])).Any();
+        }
+
+        internal static bool RequestedFacesHaveColor(object mesh, int[] faceIndices, Color color)
+        {
+            var pb = mesh as ProBuilderMesh;
+            var colors = pb?.colors;
+            var faces = ProBuilderReflection.GetFacesByIndices(mesh, faceIndices);
+            return pb != null && colors != null && faces != null && colors.Count == pb.vertexCount
+                && faces.Cast<Face>().All(face => face != null && face.indexes.Count > 0
+                    && !face.indexes.Any(index => index < 0 || index >= colors.Count || !Approximately(colors[index], color)));
+        }
+
+        internal static bool RequestedFacesUseMaterial(object mesh, int[] faceIndices, Material material)
+        {
+            var pb = mesh as ProBuilderMesh;
+            var faces = ProBuilderReflection.GetFacesByIndices(mesh, faceIndices);
+            var materials = pb == null ? null : pb.GetComponent<Renderer>()?.sharedMaterials;
+            var slot = materials == null || material == null ? -1 : Array.IndexOf(materials, material);
+            return faces != null && slot >= 0 && faces.Cast<Face>().All(face => face != null && face.submeshIndex == slot);
+        }
+
+        internal static bool RequestedFacesHaveUv(object mesh, int[] faceIndices, float? scale, float? offsetU, float? offsetV, float? rotation, bool flipU, bool flipV)
+        {
+            var faces = ProBuilderReflection.GetFacesByIndices(mesh, faceIndices);
+            return faces != null && faces.Cast<Face>().All(face => FaceUvMatches(face, scale, offsetU, offsetV, rotation, flipU, flipV));
+        }
+
+        internal static bool RequestedFacesHaveSmoothingGroup(object mesh, int[] faceIndices, int smoothingGroup)
+        {
+            var faces = ProBuilderReflection.GetFacesByIndices(mesh, faceIndices);
+            return faces != null && faces.Cast<Face>().All(face => face != null && face.smoothingGroup == smoothingGroup);
+        }
+
+        private static bool FaceUvMatches(Face face, float? scale, float? offsetU, float? offsetV, float? rotation, bool flipU, bool flipV)
+        {
+            if (face == null) return false;
+            var uv = face.uv;
+            return (!scale.HasValue || Approximately(uv.scale.x, scale.Value) && Approximately(uv.scale.y, scale.Value))
+                && (!offsetU.HasValue || Approximately(uv.offset.x, offsetU.Value))
+                && (!offsetV.HasValue || Approximately(uv.offset.y, offsetV.Value))
+                && (!rotation.HasValue || Approximately(uv.rotation, rotation.Value))
+                && uv.flipU == flipU && uv.flipV == flipV;
+        }
+
+        private static bool HasCommonExtrusionOffset(IList<Vector3> positions, IList<Vector3> points, float distance)
+        {
+            var first = points[0];
+            foreach (var candidate in positions)
+            {
+                var offset = candidate - first;
+                if (!Finite(offset) || !Approximately(offset.magnitude, distance)) continue;
+                if (points.All(point => positions.Any(value => Approximately(value, point + offset)))) return true;
+            }
+            return false;
+        }
+
+        private static bool ReadableGeometry(object mesh)
+            => mesh != null && ProBuilderReflection.GetVertexCount(mesh) > 0 && ProBuilderReflection.GetFaceCount(mesh) > 0 && CapturePositions(mesh) != null;
+
+        private static List<string> TriangleSignatures(IList<Vector3> vertices, IList<int> triangles)
+        {
+            var result = new List<string>();
+            for (var index = 0; index < triangles.Count; index += 3)
+                result.Add(TriangleSignature(vertices[triangles[index]], vertices[triangles[index + 1]], vertices[triangles[index + 2]]));
+            result.Sort(StringComparer.Ordinal);
+            return result;
+        }
+
+        private static string TriangleSignature(Vector3 a, Vector3 b, Vector3 c)
+        {
+            var values = new[] { Describe(a), Describe(b), Describe(c) };
+            var rotations = new[]
+            {
+                values[0] + "|" + values[1] + "|" + values[2],
+                values[1] + "|" + values[2] + "|" + values[0],
+                values[2] + "|" + values[0] + "|" + values[1]
+            };
+            Array.Sort(rotations, StringComparer.Ordinal);
+            return rotations[0];
+        }
+
+        private static string Describe(Vector3 value)
+            => string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:R},{1:R},{2:R}", value.x, value.y, value.z);
+
+        private static bool Finite(Vector3 value) => Finite(value.x) && Finite(value.y) && Finite(value.z);
+        private static bool Finite(float value) => !float.IsNaN(value) && !float.IsInfinity(value);
+        private static bool Approximately(Vector3 left, Vector3 right) => (left - right).sqrMagnitude <= Epsilon * Epsilon;
+        private static bool Approximately(Color left, Color right) => Mathf.Abs(left.r - right.r) <= Epsilon && Mathf.Abs(left.g - right.g) <= Epsilon && Mathf.Abs(left.b - right.b) <= Epsilon && Mathf.Abs(left.a - right.a) <= Epsilon;
+        private static bool Approximately(float left, float right) => Mathf.Abs(left - right) <= Epsilon;
+    }
+}
+#endif