wip(assembler): round L32 -- smooth Gradient interface at full amplitude (no rings, not flat)

Band faces now use signed distance to the displaced solid intervals, continuous across bands, so
MC interpolates the interface instead of terracing at density levels. The Gradient amplitude is
restored to width/8 (about 4 m peak-to-peak at 16 m). Ring/terrace audit at LOD0-8 on the FI floor and SW
ceiling passes; negative controls: L30 (rings) and L31 (flat) both fail. Hole/interface audits,
16 passage rows and 24/24 determinism pass. Evaluator 20. Cost vs L31 SW +1.9%, FI +1.5%.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX

Standalone/Core/src/FarShellsInternal.h

@@ -1217,6 +1217,82 @@ inline void AppendFarStratumShells(const FStandaloneOwnerWorld& World,const FSta
     Mesh.NumSurfaceVertices=OldSurfaceVertices+AddedVertices;
 }
 
+// Fill only underside cells that marching cubes missed. Active transitions use the
+// same displaced face and passage-mouth fade as the signed-distance field.
+struct FTransitionFaceReplacement
+{
+    double BaseZVoxels=0.0;
+    double MaximumDisplacementVoxels=0.0;
+    std::vector<uint8> Cells;
+};
+
+inline int32 RemoveCoarseTransitionFaceTriangles(FVoxelMeshData& Mesh,
+    const FIntVector& Origin,int32 Step,int32 GridSide,double VoxelSizeCm,
+    const std::vector<FTransitionFaceReplacement>& Replacements,bool bUpward)
+{
+    if(Step<=0||GridSide<2||VoxelSizeCm<=0.0||Replacements.empty())return 0;
+    const int32 TriangleCount=Mesh.Triangles.Num()/3;
+    const int32 OldCeilingStart=std::max(0,TriangleCount-Mesh.NumCeilingTriangles);
+    TArray<uint8> OldMasks=Mesh.TriangleSkirtFaceMasks;
+    OldMasks.SetNum(TriangleCount);
+    TArray<int32> KeptTriangles;
+    TArray<uint8> KeptMasks;
+    KeptTriangles.Reserve(Mesh.Triangles.Num());
+    KeptMasks.Reserve(TriangleCount);
+    int32 Removed=0,RemovedCeiling=0;
+    const int32 CellSide=GridSide-1;
+    for(int32 Triangle=0;Triangle<TriangleCount;++Triangle)
+    {
+        const int32 IA=Mesh.Triangles[Triangle*3];
+        const int32 IB=Mesh.Triangles[Triangle*3+1];
+        const int32 IC=Mesh.Triangles[Triangle*3+2];
+        bool bRemove=false;
+        if(OldMasks[Triangle]==0&&IA>=0&&IB>=0&&IC>=0
+            &&IA<Mesh.Vertices.Num()&&IB<Mesh.Vertices.Num()&&IC<Mesh.Vertices.Num())
+        {
+            const FVector& A=Mesh.Vertices[IA];
+            const FVector& B=Mesh.Vertices[IB];
+            const FVector& C=Mesh.Vertices[IC];
+            const FVector GeometricNormal=FVector::CrossProduct(B-A,C-A);
+            const double NormalLength=GeometricNormal.Size();
+            const double Facing=NormalLength>1.0e-12?GeometricNormal.Z/NormalLength:0.0;
+            if((bUpward&&Facing>0.35)||(!bUpward&&Facing< -0.35))
+            {
+                const double X=(A.X+B.X+C.X)/(3.0*VoxelSizeCm);
+                const double Y=(A.Y+B.Y+C.Y)/(3.0*VoxelSizeCm);
+                const double Z=(A.Z+B.Z+C.Z)/(3.0*VoxelSizeCm);
+                const int32 CellX=static_cast<int32>(std::floor((X-Origin.X)/Step));
+                const int32 CellY=static_cast<int32>(std::floor((Y-Origin.Y)/Step));
+                if(CellX>=0&&CellX<CellSide&&CellY>=0&&CellY<CellSide)
+                {
+                    const std::size_t Cell=static_cast<std::size_t>(CellY)*CellSide+CellX;
+                    for(const auto& Replacement:Replacements)
+                    {
+                        if(Cell>=Replacement.Cells.size()||!Replacement.Cells[Cell])continue;
+                        const double Margin=Replacement.MaximumDisplacementVoxels+4.0;
+                        if(Z>=Replacement.BaseZVoxels-Margin
+                            &&Z<=Replacement.BaseZVoxels+Margin)
+                        {bRemove=true;break;}
+                    }
+                }
+            }
+        }
+        if(bRemove)
+        {
+            ++Removed;
+            if(Triangle>=OldCeilingStart)++RemovedCeiling;
+            continue;
+        }
+        KeptTriangles.Add(IA);KeptTriangles.Add(IB);KeptTriangles.Add(IC);
+        KeptMasks.Add(OldMasks[Triangle]);
+    }
+    if(Removed==0)return 0;
+    Mesh.Triangles=std::move(KeptTriangles);
+    Mesh.TriangleSkirtFaceMasks=std::move(KeptMasks);
+    Mesh.NumCeilingTriangles=std::max(0,Mesh.NumCeilingTriangles-RemovedCeiling);
+    return Removed;
+}
+
 inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     const FStandaloneShapeWorld& Shape,const FVoxelTileKey& Key,int32 Step,FVoxelMeshData& Mesh)
 {
@@ -1230,9 +1306,14 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     {
         double FaceZ=0.0;
         double Thickness=0.0;
+        double MaximumDisplacementVoxels=0.0;
+        std::vector<double> FaceHeights;
         std::vector<uint8> SolidAbove;
+        const VoxelForgeCore::ResolvedLayoutStratumV2* Stratum=nullptr;
+        bool bTransition=false;
     };
     std::vector<FCandidate> Candidates;
+    std::vector<FTransitionFaceReplacement> Replacements;
     const double CoreMicrons=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
     for(const FStrateSlot& Slot:World.Manager->GetLayout())
     {
@@ -1243,19 +1324,34 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
         Candidate.FaceZ=static_cast<double>(Stratum->ceiling.bottomMicrometres)/CoreMicrons;
         Candidate.Thickness=static_cast<double>(Stratum->ceiling.topMicrometres
             -Stratum->ceiling.bottomMicrometres)/CoreMicrons;
-        if(Candidate.FaceZ<Origin.Z-1.0e-6||Candidate.FaceZ>Origin.Z+Extent+1.0e-6)continue;
+        Candidate.Stratum=Stratum;
+        const auto* transitionUpper=Shape.FindResolvedLayoutStratumByOrder(Stratum->order-1);
+        const bool bTransition=transitionUpper
+            &&Shape.IsResolvedLayoutTransitionActive(*transitionUpper);
+        const double displacement=bTransition?static_cast<double>(
+            Shape.ResolvedTransitionMaximumFaceDisplacementMicrometres(*transitionUpper,*Stratum))
+            /CoreMicrons:0.0;
+        if(Candidate.FaceZ<Origin.Z-displacement-1.0e-6
+            ||Candidate.FaceZ>Origin.Z+Extent+displacement+1.0e-6)continue;
+        Candidate.bTransition=bTransition;
+        Candidate.MaximumDisplacementVoxels=displacement;
         const double Epsilon=std::min(0.5,Candidate.Thickness*0.25);
         if(Epsilon<=0.0)continue;
-        Candidate.SolidAbove.resize(static_cast<std::size_t>(GridSide)*GridSide,0);
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        Candidate.FaceHeights.resize(GridCount,Candidate.FaceZ);
+        Candidate.SolidAbove.resize(GridCount,0);
         bool AnySolidAbove=false;
         for(int32 Y=0;Y<GridSide;++Y)for(int32 X=0;X<GridSide;++X)
         {
             const double WorldX=Origin.X+X*GridStep;
             const double WorldY=Origin.Y+Y*GridStep;
+            const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
+            Candidate.bTransition=Shape.ResolvedCeilingBottomAt(*Candidate.Stratum,
+                WorldX,WorldY,Candidate.FaceHeights[GridIndex])||Candidate.bTransition;
             const float Above=Shape.DensityAt(static_cast<float>(WorldX),static_cast<float>(WorldY),
-                static_cast<float>(Candidate.FaceZ+Epsilon));
+                static_cast<float>(Candidate.FaceHeights[GridIndex]+Epsilon));
             const bool bSolidAbove=std::isfinite(Above)&&Above<0.0f;
-            Candidate.SolidAbove[static_cast<std::size_t>(Y*GridSide+X)]=bSolidAbove?1:0;
+            Candidate.SolidAbove[GridIndex]=bSolidAbove?1:0;
             AnySolidAbove=AnySolidAbove||bSolidAbove;
         }
         if(AnySolidAbove)Candidates.push_back(std::move(Candidate));
@@ -1277,8 +1373,19 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     std::vector<int32> NewTriangles;
     for(const FCandidate& Candidate:Candidates)
     {
-        std::vector<int32> VertexMap(static_cast<std::size_t>(GridSide)*GridSide,INDEX_NONE);
-        const double CeilingZ=Candidate.FaceZ;
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        std::vector<int32> VertexMap(GridCount,INDEX_NONE);
+        FTransitionFaceReplacement Replacement;
+        Replacement.BaseZVoxels=Candidate.FaceZ;
+        Replacement.MaximumDisplacementVoxels=Candidate.MaximumDisplacementVoxels;
+        Replacement.Cells.resize(static_cast<std::size_t>(GridSide-1)*(GridSide-1),0);
+        const auto heightAt=[&](double X,double Y)
+        {
+            if(!Candidate.bTransition)return Candidate.FaceZ;
+            double height=Candidate.FaceZ;
+            Shape.ResolvedCeilingBottomAt(*Candidate.Stratum,X,Y,height);
+            return height;
+        };
         const auto AddVertex=[&](int32 X,int32 Y)
         {
             const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
@@ -1286,8 +1393,20 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
             if(Mapped!=INDEX_NONE)return Mapped;
             Mapped=static_cast<int32>(NewVertices.size());
             const double WorldX=Origin.X+X*GridStep,WorldY=Origin.Y+Y*GridStep;
-            NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,CeilingZ*VoxelSizeCm);
-            NewNormals.emplace_back(0.0,0.0,-1.0);
+            const double FaceZ=Candidate.FaceHeights[GridIndex];
+            FVector Normal(0.0,0.0,-1.0);
+            if(Candidate.bTransition)
+            {
+                const double Delta=std::max(1.0,std::min<double>(GridStep,4.0));
+                const double DX=(heightAt(WorldX+Delta,WorldY)-heightAt(WorldX-Delta,WorldY))
+                    /(2.0*Delta);
+                const double DY=(heightAt(WorldX,WorldY+Delta)-heightAt(WorldX,WorldY-Delta))
+                    /(2.0*Delta);
+                Normal=FVector(DX,DY,-1.0);
+                Normal.Normalize();
+            }
+            NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,FaceZ*VoxelSizeCm);
+            NewNormals.push_back(Normal);
             if(bHasUVs)NewUVs.emplace_back(static_cast<float>(WorldX),static_cast<float>(WorldY));
             if(bHasColors)NewColors.push_back(Color);
             return Mapped;
@@ -1300,15 +1419,40 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
                 ||!Candidate.SolidAbove[I01]||!Candidate.SolidAbove[I11])continue;
             const double CellX0=Origin.X+X*GridStep,CellY0=Origin.Y+Y*GridStep;
             const double CellX1=CellX0+GridStep,CellY1=CellY0+GridStep;
-            // Suppress a coincident plane only when it covers the full cell. A hit at just the
-            // center of a curved shell triangle is not enough to leave the rest of this cap cell open.
-            if(MeshIndex.HasDownwardCellCoverage(CellX0,CellY0,CellX1,CellY1,CeilingZ,0.001))continue;
+            bool fullyCovered=false;
+            if(!Candidate.bTransition)
+                fullyCovered=MeshIndex.HasDownwardCellCoverage(
+                    CellX0,CellY0,CellX1,CellY1,Candidate.FaceZ,0.001);
+            else
+            {
+                fullyCovered=true;
+                constexpr double CoverageSamples[5][2]={
+                    {0.0,0.0},{1.0,0.0},{0.0,1.0},{1.0,1.0},{0.5,0.5}};
+                for(const auto& Sample:CoverageSamples)
+                {
+                    const double U=Sample[0],V=Sample[1];
+                    const double SampleX=CellX0+(CellX1-CellX0)*U;
+                    const double SampleY=CellY0+(CellY1-CellY0)*V;
+                    const double SampleZ=heightAt(SampleX,SampleY);
+                    if(!MeshIndex.HasDownwardHit(SampleX,SampleY,SampleZ,0.25))
+                        fullyCovered=false;
+                }
+            }
+            if(fullyCovered)continue;
+            if(Key.Level>=4&&Candidate.bTransition)
+                Replacement.Cells[static_cast<std::size_t>(Y)*(GridSide-1)+X]=1;
             const int32 A=AddVertex(X,Y),B=AddVertex(X+1,Y);
             const int32 C=AddVertex(X+1,Y+1),D=AddVertex(X,Y+1);
             NewTriangles.insert(NewTriangles.end(),{A,C,B,A,D,C});
         }
+        if(Key.Level>=4&&Candidate.bTransition
+            &&std::any_of(Replacement.Cells.begin(),Replacement.Cells.end(),
+                [](uint8 Value){return Value!=0;}))
+            Replacements.push_back(std::move(Replacement));
     }
     if(NewTriangles.empty())return;
+    const int32 removedCoarse=RemoveCoarseTransitionFaceTriangles(Mesh,Origin,GridStep,
+        GridSide,VoxelSizeCm,Replacements,false);
 
     const int32 AddedVertices=static_cast<int32>(NewVertices.size());
     auto InsertVertices=[&](auto& Existing,const auto& Added)
@@ -1347,9 +1491,8 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     Mesh.NumCeilingTriangles+=static_cast<int32>(NewTriangles.size()/3);
 }
 
-// Add the interior-facing top of each bedrock band. The density composition already
-// makes this band solid and editable; this planar closure keeps its visible floor
-// continuous when a coarse marching-cubes step would otherwise skip a sub-voxel band.
+// Fill only top cells that marching cubes missed. Active transitions use the same
+// displaced face and passage-mouth fade as the signed-distance field.
 inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     const FStandaloneShapeWorld& Shape,const FVoxelTileKey& Key,int32 Step,FVoxelMeshData& Mesh)
 {
@@ -1358,8 +1501,16 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     const int32 Extent=Key.ExtentVoxels();
     if(Extent<=0||Extent%Step!=0)return;
     const int32 GridSide=Extent/Step+1;
-    struct FCandidate { double FloorZ=0.0; double Thickness=0.0; };
+    struct FCandidate
+    {
+        double FloorZ=0.0;
+        double Thickness=0.0;
+        double MaximumDisplacementVoxels=0.0;
+        const VoxelForgeCore::ResolvedLayoutStratumV2* Stratum=nullptr;
+        bool bTransition=false;
+    };
     std::vector<FCandidate> Candidates;
+    std::vector<FTransitionFaceReplacement> Replacements;
     const double CoreMicrons=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
     for(const FStrateSlot& Slot:World.Manager->GetLayout())
     {
@@ -1367,9 +1518,17 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
         if(!Stratum||!Stratum->bedrock.presentInCurrentField
             ||Stratum->bedrock.topMicrometres<=Stratum->bedrock.bottomMicrometres)continue;
         const double FloorZ=static_cast<double>(Stratum->bedrock.topMicrometres)/CoreMicrons;
-        if(FloorZ<Origin.Z-1.0e-6||FloorZ>Origin.Z+Extent+1.0e-6)continue;
+        const auto* transitionLower=Shape.FindResolvedLayoutStratumByOrder(Stratum->order+1);
+        const bool bTransition=transitionLower
+            &&Shape.IsResolvedLayoutTransitionActive(*Stratum);
+        const double displacement=bTransition
+            ?static_cast<double>(Shape.ResolvedTransitionMaximumFaceDisplacementMicrometres(
+                *Stratum,*transitionLower))/CoreMicrons
+            :0.0;
+        if(FloorZ<Origin.Z-displacement-1.0e-6
+            ||FloorZ>Origin.Z+Extent+displacement+1.0e-6)continue;
         Candidates.push_back({FloorZ,static_cast<double>(Stratum->bedrock.topMicrometres
-            -Stratum->bedrock.bottomMicrometres)/CoreMicrons});
+            -Stratum->bedrock.bottomMicrometres)/CoreMicrons,displacement,Stratum,bTransition});
     }
     if(Candidates.empty())return;
 
@@ -1390,16 +1549,34 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     {
         const double Epsilon=std::min(0.5,Candidate.Thickness*0.25);
         if(Epsilon<=0.0)continue;
-        std::vector<uint8> SolidBelow(static_cast<std::size_t>(GridSide)*GridSide,0);
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        std::vector<double> faceHeights(GridCount,Candidate.FloorZ);
+        std::vector<uint8> solidBelow(GridCount,0);
+        FTransitionFaceReplacement Replacement;
+        Replacement.BaseZVoxels=Candidate.FloorZ;
+        Replacement.MaximumDisplacementVoxels=Candidate.MaximumDisplacementVoxels;
+        Replacement.Cells.resize(static_cast<std::size_t>(GridSide-1)*(GridSide-1),0);
         for(int32 Y=0;Y<GridSide;++Y)for(int32 X=0;X<GridSide;++X)
         {
             const double WorldX=Origin.X+X*Step,WorldY=Origin.Y+Y*Step;
+            const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
+            if(Candidate.bTransition)
+                Shape.ResolvedBedrockTopAt(*Candidate.Stratum,WorldX,WorldY,
+                    faceHeights[GridIndex]);
             const float Density=Shape.DensityAt(static_cast<float>(WorldX),static_cast<float>(WorldY),
-                static_cast<float>(Candidate.FloorZ-Epsilon));
-            SolidBelow[static_cast<std::size_t>(Y*GridSide+X)]=
+                static_cast<float>(faceHeights[GridIndex]-Epsilon));
+            solidBelow[GridIndex]=
                 std::isfinite(Density)&&Density<0.0f?1:0;
         }
-        std::vector<int32> VertexMap(static_cast<std::size_t>(GridSide)*GridSide,INDEX_NONE);
+        const auto heightAt=[&](double X,double Y)
+        {
+            if(!Candidate.bTransition)return Candidate.FloorZ;
+            double height=Candidate.FloorZ;
+            if(Candidate.bTransition)
+                Shape.ResolvedBedrockTopAt(*Candidate.Stratum,X,Y,height);
+            return height;
+        };
+        std::vector<int32> VertexMap(GridCount,INDEX_NONE);
         const auto AddVertex=[&](int32 X,int32 Y)
         {
             const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
@@ -1407,9 +1584,20 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
             if(Mapped!=INDEX_NONE)return Mapped;
             Mapped=static_cast<int32>(NewVertices.size());
             const double WorldX=Origin.X+X*Step,WorldY=Origin.Y+Y*Step;
+            FVector Normal(0.0,0.0,1.0);
+            if(Candidate.bTransition)
+            {
+                const double Delta=std::max(1.0,std::min<double>(Step,4.0));
+                const double DX=(heightAt(WorldX+Delta,WorldY)-heightAt(WorldX-Delta,WorldY))
+                    /(2.0*Delta);
+                const double DY=(heightAt(WorldX,WorldY+Delta)-heightAt(WorldX,WorldY-Delta))
+                    /(2.0*Delta);
+                Normal=FVector(-DX,-DY,1.0);
+                Normal.Normalize();
+            }
             NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,
-                Candidate.FloorZ*VoxelSizeCm);
-            NewNormals.emplace_back(0.0,0.0,1.0);
+                faceHeights[GridIndex]*VoxelSizeCm);
+            NewNormals.push_back(Normal);
             if(bHasUVs)NewUVs.emplace_back(static_cast<float>(WorldX),static_cast<float>(WorldY));
             if(bHasColors)NewColors.push_back(Color);
             return Mapped;
@@ -1418,16 +1606,43 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
         {
             const std::size_t I00=static_cast<std::size_t>(Y*GridSide+X);
             const std::size_t I10=I00+1,I01=I00+GridSide,I11=I01+1;
-            if(!SolidBelow[I00]||!SolidBelow[I10]||!SolidBelow[I01]||!SolidBelow[I11])continue;
+            if(!solidBelow[I00]||!solidBelow[I10]||!solidBelow[I01]||!solidBelow[I11])continue;
             const double X0=Origin.X+X*Step,Y0=Origin.Y+Y*Step;
             const double X1=X0+Step,Y1=Y0+Step;
-            if(MeshIndex.HasUpwardCellCoverage(X0,Y0,X1,Y1,Candidate.FloorZ,0.001))continue;
+            bool fullyCovered=false;
+            if(!Candidate.bTransition)
+                fullyCovered=MeshIndex.HasUpwardCellCoverage(
+                    X0,Y0,X1,Y1,Candidate.FloorZ,0.001);
+            else
+            {
+                fullyCovered=true;
+                constexpr double CoverageSamples[5][2]={
+                    {0.0,0.0},{1.0,0.0},{0.0,1.0},{1.0,1.0},{0.5,0.5}};
+                for(const auto& Sample:CoverageSamples)
+                {
+                    const double U=Sample[0],V=Sample[1];
+                    const double SampleX=X0+(X1-X0)*U;
+                    const double SampleY=Y0+(Y1-Y0)*V;
+                    const double SampleZ=heightAt(SampleX,SampleY);
+                    if(!MeshIndex.HasUpwardHit(SampleX,SampleY,SampleZ,0.25))
+                        fullyCovered=false;
+                }
+            }
+            if(fullyCovered)continue;
+            if(Key.Level>=4&&Candidate.bTransition)
+                Replacement.Cells[static_cast<std::size_t>(Y)*(GridSide-1)+X]=1;
             const int32 A=AddVertex(X,Y),B=AddVertex(X+1,Y);
             const int32 C=AddVertex(X+1,Y+1),D=AddVertex(X,Y+1);
             NewTriangles.insert(NewTriangles.end(),{A,B,C,A,C,D});
         }
+        if(Key.Level>=4&&Candidate.bTransition
+            &&std::any_of(Replacement.Cells.begin(),Replacement.Cells.end(),
+                [](uint8 Value){return Value!=0;}))
+            Replacements.push_back(std::move(Replacement));
     }
     if(NewTriangles.empty())return;
+    const int32 removedCoarse=RemoveCoarseTransitionFaceTriangles(Mesh,Origin,Step,
+        GridSide,VoxelSizeCm,Replacements,true);
 
     const int32 AddedVertices=static_cast<int32>(NewVertices.size());
     auto InsertVertices=[&](auto& Existing,const auto& Added)