wip(L15, side branch): extended far gate + rejected far-mesh candidates (null result)

Refine x2 at LOD4-8 saves 13.6% but breaks the 1 px rule, shading and swaps, and opens holes; station x2 and ray removal open connector gaps. Not for assembler/world. See Linux15/REPORT.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX
2026-10-20 03:29:13 +02:00
1 parent a176d0743a
commit a6185b1a3f
@@ -42,6 +42,7 @@ namespace StandaloneScreenSpaceGate
        double MaximumSlopeDegrees=0.0;
        std::array<std::uint64_t,4> SlopeSamples{};
        std::array<double,4> SlopeP99{},SlopeMaximum{};
+        std::vector<double> SamplePixels;
        bool Valid=false;
    };

@@ -52,6 +53,14 @@ namespace StandaloneScreenSpaceGate
        double SlopeY=0.0;
    };

+    struct FMeshSurfaceHit
+    {
+        double Z=0.0;
+        std::array<double,3> Normal{};
+        std::array<std::uint8_t,4> Color{};
+        bool Ceiling=false;
+    };
+
    struct FViewBasis
    {
        std::array<double,3> Right{};
@@ -162,7 +171,7 @@ namespace StandaloneScreenSpaceGate
    {
        int Side=65;
        double MinimumX=0.0,MaximumX=0.0,MinimumY=0.0,MaximumY=0.0;
-        std::vector<std::vector<double>> Hits;
+        std::vector<std::vector<FMeshSurfaceHit>> Hits;

        FHeightGrid()=default;
        FHeightGrid(int InSide,double MinX,double MaxX,double MinY,double MaxY)
@@ -175,13 +184,13 @@ namespace StandaloneScreenSpaceGate
        double Y(int Iy) const
        {return MinimumY+(MaximumY-MinimumY)*Iy/(Side-1);}

-        void Add(int Ix,int Iy,double Z)
+        void Add(int Ix,int Iy,const FMeshSurfaceHit& Hit)
        {
            auto& Values=Hits[static_cast<std::size_t>(Iy)*Side+Ix];
-            Values.push_back(Z);
+            Values.push_back(Hit);
        }

-        const std::vector<double>& At(int Ix,int Iy) const
+        const std::vector<FMeshSurfaceHit>& At(int Ix,int Iy) const
        {return Hits[static_cast<std::size_t>(Iy)*Side+Ix];}
    };

@@ -246,6 +255,8 @@ namespace StandaloneScreenSpaceGate
        {
            if(!Tile||Tile->Indices.size()<3)continue;
            const std::size_t TriangleCount=Tile->Indices.size()/3;
+            const std::size_t CeilingStart=TriangleCount
+                -std::min<std::size_t>(TriangleCount,Tile->CeilingTriangleCount);
            for(std::size_t Triangle=0;Triangle<TriangleCount;++Triangle)
            {
                if(Triangle<Tile->TriangleSkirtFaceMasks.size()
@@ -274,15 +285,33 @@ namespace StandaloneScreenSpaceGate
                    const double W1=((C[1]-A[1])*(X-C[0])+(A[0]-C[0])*(Y-C[1]))/Denominator;
                    const double W2=1.0-W0-W1;
                    if(W0<-1e-6||W1<-1e-6||W2<-1e-6)continue;
-                    Grid.Add(Ix,Iy,W0*A[2]+W1*B[2]+W2*C[2]);
+                    const auto& VA=Tile->Vertices[I0];
+                    const auto& VB=Tile->Vertices[I1];
+                    const auto& VC=Tile->Vertices[I2];
+                    std::array<double,3> Normal{};
+                    for(int Axis=0;Axis<3;++Axis)
+                        Normal[Axis]=W0*VA.Normal[Axis]+W1*VB.Normal[Axis]+W2*VC.Normal[Axis];
+                    const double NormalLength=std::sqrt(Normal[0]*Normal[0]
+                        +Normal[1]*Normal[1]+Normal[2]*Normal[2]);
+                    if(NormalLength>1.0e-12)
+                        for(double& Component:Normal)Component/=NormalLength;
+                    std::array<std::uint8_t,4> Color{};
+                    if(Tile->VertexColors.size()==Tile->Vertices.size())
+                        for(int Channel=0;Channel<4;++Channel)
+                            Color[Channel]=static_cast<std::uint8_t>(std::clamp(std::lround(
+                                W0*Tile->VertexColors[I0][Channel]
+                                +W1*Tile->VertexColors[I1][Channel]
+                                +W2*Tile->VertexColors[I2][Channel]),0l,255l));
+                    Grid.Add(Ix,Iy,{W0*A[2]+W1*B[2]+W2*C[2],Normal,Color,Triangle>=CeilingStart});
                }
            }
        }
        for(auto& Values:Grid.Hits)
        {
-            std::sort(Values.begin(),Values.end());
-            Values.erase(std::unique(Values.begin(),Values.end(),[](double A,double B)
-                {return std::abs(A-B)<0.02;}),Values.end());
+            std::stable_sort(Values.begin(),Values.end(),[](const FMeshSurfaceHit& A,
+                const FMeshSurfaceHit& B){return A.Z<B.Z;});
+            Values.erase(std::unique(Values.begin(),Values.end(),[](const FMeshSurfaceHit& A,
+                const FMeshSurfaceHit& B){return std::abs(A.Z-B.Z)<0.02;}),Values.end());
        }
        return Grid;
    }
@@ -335,14 +364,14 @@ namespace StandaloneScreenSpaceGate
        return Roots;
    }

-    inline bool MatchNearest(const std::vector<double>& Hits,const std::vector<bool>& Used,
+    inline bool MatchNearest(const std::vector<FMeshSurfaceHit>& Hits,const std::vector<bool>& Used,
        double Root,std::size_t& OutIndex,double& OutError)
    {
        double Best=std::numeric_limits<double>::infinity();std::size_t BestIndex=Hits.size();
        for(std::size_t I=0;I<Hits.size();++I)
            if(I>=Used.size()||!Used[I])
            {
-                const double Error=std::abs(Hits[I]-Root);
+                const double Error=std::abs(Hits[I].Z-Root);
                if(Error<Best){Best=Error;BestIndex=I;}
            }
        if(BestIndex==Hits.size())return false;
@@ -371,7 +400,7 @@ namespace StandaloneScreenSpaceGate
                    continue;
                }
                Used[HitIndex]=true;
-                AddError(Accumulator,MeshGrid.At(Ix,Iy)[HitIndex]-Root.ZMeters,
+                AddError(Accumulator,MeshGrid.At(Ix,Iy)[HitIndex].Z-Root.ZMeters,
                    Root,PixelBudgetMeters,View,MeshGrid.X(Ix),MeshGrid.Y(Iy));
                ++Row.Samples;
            }
@@ -399,7 +428,7 @@ namespace StandaloneScreenSpaceGate
            std::vector<bool> UsedReference(Reference.size(),false),UsedMesh(Mesh.size(),false);
            for(std::size_t ReferenceIndex=0;ReferenceIndex<Reference.size();++ReferenceIndex)
            {
-                const double ReferenceZ=Reference[ReferenceIndex];
+                const double ReferenceZ=Reference[ReferenceIndex].Z;
                UsedReference[ReferenceIndex]=true;
                std::size_t MeshIndex=0;double MeshError=0.0;
                if(!MatchNearest(Mesh,UsedMesh,ReferenceZ,MeshIndex,MeshError))
@@ -416,7 +445,7 @@ namespace StandaloneScreenSpaceGate
                    if(BestRoot!=Roots.end()&&std::abs(BestRoot->ZMeters-ReferenceZ)<1.0)
                        Root=*BestRoot;
                }
-                AddError(Accumulator,Mesh[MeshIndex]-Reference[ReferenceIndex],
+                AddError(Accumulator,Mesh[MeshIndex].Z-Reference[ReferenceIndex].Z,
                    Root,PixelBudgetMeters,View,ReferenceGrid.X(Ix),ReferenceGrid.Y(Iy));
            }
            for(std::size_t I=0;I<Mesh.size();++I)
@@ -426,6 +455,110 @@ namespace StandaloneScreenSpaceGate
        return Row;
    }

+    struct FMeshComparisonRow
+    {
+        FErrorRow Geometry;
+        std::uint64_t Holes=0,Cracks=0,Floating=0,MaterialMismatches=0;
+        double ShadeP50=0.0,ShadeP99=0.0,ShadeMaximum=0.0;
+        double NormalDegreesP50=0.0,NormalDegreesP99=0.0,NormalDegreesMaximum=0.0;
+        std::vector<double> GeometryPixels,ShadeValues,NormalAngles;
+        bool Valid=false;
+    };
+
+    inline std::array<double,3> UnitNormal(const FMeshSurfaceHit& Hit)
+    {
+        std::array<double,3> N=Hit.Normal;
+        const double Length=std::sqrt(N[0]*N[0]+N[1]*N[1]+N[2]*N[2]);
+        if(Length<=1.0e-12)return {0.0,0.0,Hit.Ceiling?-1.0:1.0};
+        for(double& Component:N)Component/=Length;
+        return N;
+    }
+
+    inline FMeshComparisonRow CompareMeshes(const FHeightGrid& Reference,
+        const FHeightGrid& Candidate,const FVoxelTileKey& Patch,double VoxelMeters,
+        double PixelBudgetMeters,const FViewBasis& View)
+    {
+        FMeshComparisonRow Row;Row.Valid=Reference.Side==Candidate.Side;
+        if(!Row.Valid)return Row;
+        FErrorAccumulator Geometry;
+        std::vector<double> ShadeValues,NormalAngles;
+        const std::size_t CellCount=static_cast<std::size_t>(Reference.Side)*Reference.Side;
+        ShadeValues.reserve(CellCount);NormalAngles.reserve(CellCount);
+        const double LightLength=std::sqrt(0.3*0.3+(-0.4)*(-0.4)+0.85*0.85);
+        const std::array<double,3> Light={0.3/LightLength,-0.4/LightLength,0.85/LightLength};
+        for(int Iy=0;Iy<Reference.Side;++Iy)
+        for(int Ix=0;Ix<Reference.Side;++Ix)
+        {
+            const auto& Before=Reference.At(Ix,Iy);
+            const auto& After=Candidate.At(Ix,Iy);
+            std::vector<bool> Used(After.size(),false);
+            for(std::size_t I=0;I<Before.size();++I)
+            {
+                std::size_t Matched=0;double Difference=0.0;
+                if(!MatchNearest(After,Used,Before[I].Z,Matched,Difference))
+                {
+                    ++Row.Holes;AddMissing(Geometry);ShadeValues.push_back(1.0);
+                    NormalAngles.push_back(180.0);continue;
+                }
+                Used[Matched]=true;
+                const FMeshSurfaceHit& A=Before[I];
+                const FMeshSurfaceHit& B=After[Matched];
+                const auto NA=UnitNormal(A),NB=UnitNormal(B);
+                const double Dot=std::clamp(NA[0]*NB[0]+NA[1]*NB[1]+NA[2]*NB[2],-1.0,1.0);
+                constexpr double Pi=3.14159265358979323846;
+                const double Angle=std::acos(Dot)*180.0/Pi;
+                NormalAngles.push_back(Angle);
+                const double DiffuseA=std::max(0.0,NA[0]*Light[0]+NA[1]*Light[1]+NA[2]*Light[2]);
+                const double DiffuseB=std::max(0.0,NB[0]*Light[0]+NB[1]*Light[1]+NB[2]*Light[2]);
+                const bool bMaterialChanged=A.Color[0]!=B.Color[0]||A.Color[3]!=B.Color[3]
+                    ||A.Ceiling!=B.Ceiling;
+                if(bMaterialChanged)++Row.MaterialMismatches;
+                const double MaterialDelta=bMaterialChanged?1.0:std::max(
+                    std::abs(static_cast<double>(A.Color[1])-B.Color[1]),
+                    std::abs(static_cast<double>(A.Color[2])-B.Color[2]))/255.0;
+                ShadeValues.push_back(std::max(std::abs(DiffuseA-DiffuseB),MaterialDelta));
+                const double NX=NA[2]<0.0?NA[0]/std::max(1.0e-12,-NA[2])
+                    :-NA[0]/std::max(1.0e-12,NA[2]);
+                const double NY=NA[2]<0.0?NA[1]/std::max(1.0e-12,-NA[2])
+                    :-NA[1]/std::max(1.0e-12,NA[2]);
+                AddError(Geometry,B.Z-A.Z,{A.Z,NX,NY},PixelBudgetMeters,View,
+                    Reference.X(Ix),Reference.Y(Iy));
+            }
+            for(std::size_t I=0;I<After.size();++I)
+                if(!Used[I])
+                {++Row.Floating;AddMissing(Geometry);ShadeValues.push_back(1.0);NormalAngles.push_back(180.0);}
+        }
+        for(int Iy=0;Iy<Reference.Side;++Iy)
+        for(int Ix=0;Ix<Reference.Side;++Ix)
+        {
+            const std::size_t Index=static_cast<std::size_t>(Iy)*Reference.Side+Ix;
+            const auto CheckEdge=[&](int NX,int NY)
+            {
+                if(NX>=Reference.Side||NY>=Reference.Side)return;
+                const auto& A=Reference.Hits[Index];
+                const auto& B=Reference.At(NX,NY);
+                const auto& CA=Candidate.Hits[Index];
+                const auto& CB=Candidate.At(NX,NY);
+                if(!A.empty()&&!B.empty()&&(CA.empty()!=CB.empty()))++Row.Cracks;
+            };
+            CheckEdge(Ix+1,Iy);CheckEdge(Ix,Iy+1);
+        }
+        Row.Geometry.Lod=Patch.Level;Row.Geometry.Valid=Row.Valid;
+        Row.Geometry.Missing=Row.Holes;Row.Geometry.Floating=Row.Floating;
+        FinalizeError(Row.Geometry,Geometry);
+        Row.ShadeP50=Percentile(ShadeValues,0.50);
+        Row.ShadeP99=Percentile(ShadeValues,0.99);
+        Row.ShadeMaximum=ShadeValues.empty()?0.0:*std::max_element(ShadeValues.begin(),ShadeValues.end());
+        Row.NormalDegreesP50=Percentile(NormalAngles,0.50);
+        Row.NormalDegreesP99=Percentile(NormalAngles,0.99);
+        Row.NormalDegreesMaximum=NormalAngles.empty()?0.0
+            :*std::max_element(NormalAngles.begin(),NormalAngles.end());
+        Row.GeometryPixels=std::move(Geometry.Pixels);
+        Row.ShadeValues=std::move(ShadeValues);
+        Row.NormalAngles=std::move(NormalAngles);
+        return Row;
+    }
+
    inline FPopRow ComparePop(const FHeightGrid& Coarse,const FHeightGrid& Fine,
        const FVoxelTileKey& Patch,double VoxelMeters,double PixelBudgetMeters,
        const VoxelForgeCore::WorldAssemblyManifest& Assembly,const FViewBasis& View)
@@ -452,11 +585,12 @@ namespace StandaloneScreenSpaceGate
                }
                CoarseUsed[CoarseIndex]=true;
                FineUsed[FineIndex]=true;
-                AddError(Accumulator,CoarseHits[CoarseIndex]-FineHits[FineIndex],
+                AddError(Accumulator,CoarseHits[CoarseIndex].Z-FineHits[FineIndex].Z,
                    Root,PixelBudgetMeters,View,Coarse.X(Ix),Coarse.Y(Iy));
                ++Row.Samples;
            }
        }
+        Row.SamplePixels=Accumulator.Pixels;
        FErrorRow Stats;Stats.Lod=Patch.Level;Stats.Valid=true;
        FinalizeError(Stats,Accumulator);
        Row.Samples=Stats.Samples;Row.P50=Stats.P50;Row.P99=Stats.P99;Row.Maximum=Stats.Maximum;
@@ -472,6 +606,16 @@ namespace StandaloneScreenSpaceGate
        return Row;
    }

+    inline bool PopNotWorseAtAnySample(const FPopRow& Before,const FPopRow& After)
+    {
+        if(!Before.Valid||!After.Valid||Before.Samples<16
+            ||Before.SamplePixels.size()!=After.SamplePixels.size()
+            ||After.Cracks>Before.Cracks||After.Floating>Before.Floating)return false;
+        for(std::size_t I=0;I<Before.SamplePixels.size();++I)
+            if(After.SamplePixels[I]>Before.SamplePixels[I]+1.0e-4)return false;
+        return true;
+    }
+
    inline std::array<double,9> ClosestDisplayedDistancesMeters(
        const FStandaloneOwnerWorld& World,const FVector& CameraVoxels,
        std::uint32_t VoxelSizeMicrons)
@@ -544,6 +688,7 @@ namespace StandaloneScreenSpaceGate

    inline bool Run(const std::array<std::optional<FStandaloneCpuTile>,9>& SampleTiles,
        FStandaloneStreamingGenerator& Streamer,
+        const std::vector<FVoxelTileKey>& DesiredKeys,
        const VoxelForgeCore::WorldAssemblyManifest& Assembly,
        const std::array<double,9>& Distances,std::uint32_t VoxelSizeMicrons,int MaxLod,
        const std::array<std::int64_t,9>& PixelBudgetsSubvoxels,
@@ -552,17 +697,26 @@ namespace StandaloneScreenSpaceGate
        const double VoxelMeters=static_cast<double>(VoxelSizeMicrons)/1000000.0;
        const FViewBasis View=MakeViewBasis(CameraYawDegrees,CameraPitchDegrees);
        std::array<double,9> Budgets{};
-        std::array<FErrorRow,9> ErrorRows{};
-        std::array<FPopRow,9> PopRows{};
+        VoxelForgeCore::TileGenerationOptions BaselineOptions;
+        BaselineOptions.overrideFarDisplayMesh=true;
+        VoxelForgeCore::TileGenerationOptions CandidateOptions;
+        CandidateOptions.overrideFarDisplayMesh=true;
+        CandidateOptions.farDisplayGeometryBudgetMillipixels=Assembly.recipe.farDisplayGeometryBudgetMillipixels;
+        CandidateOptions.farRefinementGridScale=Assembly.recipe.farRefinementGridScale;
+        CandidateOptions.farRefinementLodMask=Assembly.recipe.farRefinementLodMask;
+        CandidateOptions.farConnectorStationScale=Assembly.recipe.farConnectorStationScale;
+        CandidateOptions.farConnectorRayMask=Assembly.recipe.farConnectorRayMask;
+        CandidateOptions.farConnectorReuseStationRadii=Assembly.recipe.farConnectorReuseStationRadii;
        bool GatePass=true;
-        std::printf("[ScreenSpaceGate] angular_pixel=%.9f rad (horizontal_fov=90deg,width=2560) lod>=3_limit=1.0px sampling=65x65 skirts=excluded metric=local_surface_normal_projected field_reference=direct-Heightfield2D-roots normal_probe_vox=1 view_yaw_deg=%.3f view_pitch_deg=%.3f\n",
+        constexpr double ShadeLimit=1.0/255.0;
+        std::printf("[ScreenSpaceGate] angular_pixel=%.9f rad (horizontal_fov=90deg,width=2560) lod>=3_geometry_limit=1.0px same_lod_reference=today mesh sampling=65x65 skirts=excluded shading=max(lambert-delta,material-selector-or-blend-delta) shade_limit=1/255 normal_probe_vox=1 view_yaw_deg=%.3f view_pitch_deg=%.3f\n",
            OnePixelRadians,CameraYawDegrees,CameraPitchDegrees);
        for(int Lod=0;Lod<=MaxLod&&Lod<9;++Lod)
        {
            Budgets[Lod]=Distances[Lod]*OnePixelRadians;
            std::printf("[ScreenSpaceDistance] lod=%d closest_m=%.3f pixel_budget_m=%.6f pixel_budget_cm=%.3f pixel_budget_subvoxels=%lld rule=%s\n",
                Lod,Distances[Lod],Budgets[Lod],Budgets[Lod]*100.0,
-                static_cast<long long>(PixelBudgetsSubvoxels[Lod]),Lod<3?"exact-2cm":"1px");
+                static_cast<long long>(PixelBudgetsSubvoxels[Lod]),Lod<3?"exact-2cm":"same_lod_1px");
        }
        const double LOD3CellMeters=static_cast<double>(CHUNK_SIZE*(1<<3))*VoxelMeters/64.0;
        PrintKnownFailureControl(LOD3CellMeters,Distances[3],View);
@@ -578,115 +732,117 @@ namespace StandaloneScreenSpaceGate
            const FStandaloneCpuTile* CoarsePtr=&CoarseTile;
            const std::span<const FStandaloneCpuTile* const> CoarseSpan(&CoarsePtr,1);
            const FHeightGrid CoarseGrid=Rasterize(CoarseSpan,CoarseTile.Key,VoxelMeters);
-            const FStandaloneCpuTile ExactTile=Streamer.GenerateDiagnostic(
-                CoarseTile.Key,0,1,true);
-            const FStandaloneCpuTile* ExactPointer=&ExactTile;
-            const std::span<const FStandaloneCpuTile* const> ExactSpan(&ExactPointer,1);
-            const FHeightGrid ExactGrid=Rasterize(ExactSpan,ExactTile.Key,VoxelMeters);
-            ErrorRows[Lod]=CompareToReference(CoarseGrid,ExactGrid,CoarseTile.Key,VoxelMeters,
-                Budgets[Lod],Assembly,View);
-            const FErrorRow& Error=ErrorRows[Lod];
+            FStandaloneCpuTile BaselineTile=Streamer.GenerateDiagnostic(
+                CoarseTile.Key,0,1,true,&BaselineOptions,true);
+            const FStandaloneCpuTile* BaselinePointer=&BaselineTile;
+            const std::span<const FStandaloneCpuTile* const> BaselineSpan(&BaselinePointer,1);
+            const FHeightGrid BaselineGrid=Rasterize(BaselineSpan,BaselineTile.Key,VoxelMeters);
+            const FMeshComparisonRow MeshDelta=CompareMeshes(BaselineGrid,CoarseGrid,
+                CoarseTile.Key,VoxelMeters,Budgets[Lod],View);
+            const FErrorRow& Error=MeshDelta.Geometry;
            const bool LodPass=Error.Valid&&Error.Missing==0&&Error.Floating==0
-                &&Error.Samples>=16&&Error.Maximum<=1.0;
+                &&MeshDelta.Cracks==0&&Error.Samples>=16&&Error.Maximum<=1.0
+                &&MeshDelta.ShadeMaximum<=ShadeLimit;
            GatePass=GatePass&&LodPass;
-            std::printf("[ScreenSpaceGateLOD] lod=%d key=(%d,%d,%d) samples=%llu normal_px_p50=%.4f p99=%.4f max=%.4f vertical_px_p50=%.4f p99=%.4f max=%.4f max_normal_m=%.6f max_xy_m=(%.3f,%.3f) max_slope_deg=%.2f missing=%llu floating=%llu status=%s\n",
+            std::printf("[ScreenSpaceGateLOD] lod=%d key=(%d,%d,%d) samples=%llu geometry_px_p50=%.4f p99=%.4f max=%.4f shading_delta_p50=%.6f p99=%.6f max=%.6f normal_deg_p50=%.4f p99=%.4f max=%.4f material_mismatch=%llu holes=%llu cracks=%llu floating=%llu status=%s\n",
                Lod,CoarseTile.Key.Coord.X,CoarseTile.Key.Coord.Y,CoarseTile.Key.Coord.Z,
                static_cast<unsigned long long>(Error.Samples),Error.P50,Error.P99,Error.Maximum,
-                Error.VerticalP50,Error.VerticalP99,Error.VerticalMaximum,
-                Error.MaximumNormalDistanceMeters,Error.MaximumX,Error.MaximumY,
-                Error.MaximumSlopeDegrees,
-                static_cast<unsigned long long>(Error.Missing),static_cast<unsigned long long>(Error.Floating),
+                MeshDelta.ShadeP50,MeshDelta.ShadeP99,MeshDelta.ShadeMaximum,
+                MeshDelta.NormalDegreesP50,MeshDelta.NormalDegreesP99,MeshDelta.NormalDegreesMaximum,
+                static_cast<unsigned long long>(MeshDelta.MaterialMismatches),
+                static_cast<unsigned long long>(MeshDelta.Holes),
+                static_cast<unsigned long long>(MeshDelta.Cracks),
+                static_cast<unsigned long long>(MeshDelta.Floating),
                LodPass?"PASS":"REJECT");
-            PrintSlopeTail("same_lod",Lod,Error.SlopeSamples,Error.SlopeP99,Error.SlopeMaximum);

            const FErrorRow FieldError=CompareToExact(CoarseGrid,CoarseTile.Key,VoxelMeters,
                Budgets[Lod],Assembly,View);
            const bool FieldPass=FieldError.Valid&&FieldError.Missing==0&&FieldError.Floating==0
                &&FieldError.Samples>=16&&FieldError.Maximum<=1.0;
-            GatePass=GatePass&&FieldPass;
-            std::printf("[ScreenSpaceGateFieldLOD] lod=%d samples=%llu normal_px_p50=%.4f p99=%.4f max=%.4f vertical_px_p50=%.4f p99=%.4f max=%.4f max_normal_m=%.6f max_xyz_m=(%.3f,%.3f,%.3f) max_slope_deg=%.2f missing=%llu floating=%llu status=%s\n",
+            std::printf("[ScreenSpaceGateFieldLOD] lod=%d samples=%llu field_geometry_px_p50=%.4f p99=%.4f max=%.4f missing=%llu floating=%llu status=INFO_ONLY\n",
                Lod,static_cast<unsigned long long>(FieldError.Samples),FieldError.P50,
-                FieldError.P99,FieldError.Maximum,FieldError.VerticalP50,FieldError.VerticalP99,
-                FieldError.VerticalMaximum,FieldError.MaximumNormalDistanceMeters,
-                FieldError.MaximumX,FieldError.MaximumY,FieldError.MaximumDisplayedZ,
-                FieldError.MaximumSlopeDegrees,
+                FieldError.P99,FieldError.Maximum,
                static_cast<unsigned long long>(FieldError.Missing),
-                static_cast<unsigned long long>(FieldError.Floating),FieldPass?"PASS":"REJECT");
-            PrintSlopeTail("field",Lod,FieldError.SlopeSamples,FieldError.SlopeP99,
-                FieldError.SlopeMaximum);
+                static_cast<unsigned long long>(FieldError.Floating));

            bool FaultControlsPass=true;
-            const FHeightGrid MissingGrid(ExactGrid.Side,ExactGrid.MinimumX,ExactGrid.MaximumX,
-                ExactGrid.MinimumY,ExactGrid.MaximumY);
-            const FErrorRow MissingError=CompareToReference(MissingGrid,ExactGrid,
-                CoarseTile.Key,VoxelMeters,Budgets[Lod],Assembly,View);
-            const bool MissingRejected=MissingError.Missing>0&&MissingError.Maximum>1.0;
+            const FHeightGrid MissingGrid(BaselineGrid.Side,BaselineGrid.MinimumX,BaselineGrid.MaximumX,
+                BaselineGrid.MinimumY,BaselineGrid.MaximumY);
+            const FMeshComparisonRow MissingError=CompareMeshes(BaselineGrid,MissingGrid,
+                CoarseTile.Key,VoxelMeters,Budgets[Lod],View);
+            const bool MissingRejected=MissingError.Holes>0&&MissingError.Geometry.Maximum>1.0;
            FaultControlsPass=FaultControlsPass&&MissingRejected;
-            std::printf("[ScreenSpaceFaultInjection] lod=%d case=missing-displayed-surface missing=%llu status=%s\n",
-                Lod,static_cast<unsigned long long>(MissingError.Missing),
+            std::printf("[ScreenSpaceFaultInjection] lod=%d case=missing-displayed-surface holes=%llu status=%s\n",
+                Lod,static_cast<unsigned long long>(MissingError.Holes),
                MissingRejected?"REJECTED_AS_REQUIRED":"GATE_FALSE_NEGATIVE");

-            FStandaloneCpuTile FloatingTile=CoarseTile;
+            FStandaloneCpuTile FloatingTile=BaselineTile;
            const std::uint32_t FloatingVertexBase=static_cast<std::uint32_t>(FloatingTile.Vertices.size());
-            for(FStandaloneCpuVertex Vertex:CoarseTile.Vertices)
+            for(FStandaloneCpuVertex Vertex:BaselineTile.Vertices)
            {
                Vertex.Position[2]+=2.0f;
                FloatingTile.Vertices.push_back(Vertex);
            }
-            for(const std::uint32_t Index:CoarseTile.Indices)
+            FloatingTile.VertexColors.insert(FloatingTile.VertexColors.end(),
+                BaselineTile.VertexColors.begin(),BaselineTile.VertexColors.end());
+            for(const std::uint32_t Index:BaselineTile.Indices)
                FloatingTile.Indices.push_back(FloatingVertexBase+Index);
            FloatingTile.TriangleSkirtFaceMasks.insert(FloatingTile.TriangleSkirtFaceMasks.end(),
-                CoarseTile.TriangleSkirtFaceMasks.begin(),CoarseTile.TriangleSkirtFaceMasks.end());
+                BaselineTile.TriangleSkirtFaceMasks.begin(),BaselineTile.TriangleSkirtFaceMasks.end());
            const FStandaloneCpuTile* FloatingPointer=&FloatingTile;
            const std::span<const FStandaloneCpuTile* const> FloatingSpan(&FloatingPointer,1);
-            const FHeightGrid FloatingGrid=Rasterize(FloatingSpan,CoarseTile.Key,VoxelMeters);
-            const FErrorRow FloatingError=CompareToReference(FloatingGrid,ExactGrid,
-                CoarseTile.Key,VoxelMeters,Budgets[Lod],Assembly,View);
-            const bool FloatingRejected=FloatingError.Floating>0||FloatingError.Maximum>1.0;
+            const FHeightGrid FloatingGrid=Rasterize(FloatingSpan,BaselineTile.Key,VoxelMeters);
+            const FMeshComparisonRow FloatingError=CompareMeshes(BaselineGrid,FloatingGrid,
+                CoarseTile.Key,VoxelMeters,Budgets[Lod],View);
+            const bool FloatingRejected=FloatingError.Floating>0||FloatingError.Geometry.Maximum>1.0;
            FaultControlsPass=FaultControlsPass&&FloatingRejected;
            std::printf("[ScreenSpaceFaultInjection] lod=%d case=2m-floating-surface floating=%llu max_px=%.4f status=%s\n",
-                Lod,static_cast<unsigned long long>(FloatingError.Floating),FloatingError.Maximum,
+                Lod,static_cast<unsigned long long>(FloatingError.Floating),FloatingError.Geometry.Maximum,
                FloatingRejected?"REJECTED_AS_REQUIRED":"GATE_FALSE_NEGATIVE");

-            std::vector<FStandaloneCpuTile> FineTiles;
-            FineTiles.reserve(8);
+            std::vector<FStandaloneCpuTile> FineBeforeTiles,FineAfterTiles;
+            FineBeforeTiles.reserve(8);FineAfterTiles.reserve(8);
            for(int Dz=0;Dz<=1;++Dz)
            for(int Dy=0;Dy<=1;++Dy)
            for(int Dx=0;Dx<=1;++Dx)
            {
                const FVoxelTileKey FineKey(FIntVector(2*CoarseTile.Key.Coord.X+Dx,
                    2*CoarseTile.Key.Coord.Y+Dy,2*CoarseTile.Key.Coord.Z+Dz),Lod-1);
-                FStandaloneCpuTile FineTile=Streamer.GenerateDiagnostic(FineKey);
-                if(!FineTile.Vertices.empty())FineTiles.push_back(std::move(FineTile));
+                FStandaloneCpuTile FineBefore=Streamer.GenerateDiagnostic(
+                    FineKey,0,1,true,&BaselineOptions,true);
+                FStandaloneCpuTile FineAfter=Streamer.GenerateDiagnostic(
+                    FineKey,0,1,true,nullptr,true);
+                if(!FineBefore.Vertices.empty())FineBeforeTiles.push_back(std::move(FineBefore));
+                if(!FineAfter.Vertices.empty())FineAfterTiles.push_back(std::move(FineAfter));
            }
-            std::vector<const FStandaloneCpuTile*> FinePointers;
-            FinePointers.reserve(FineTiles.size());
-            for(const auto& Tile:FineTiles)FinePointers.push_back(&Tile);
-            const auto FineSpan=std::span<const FStandaloneCpuTile* const>(
-                FinePointers.data(),FinePointers.size());
-            const FHeightGrid FineGrid=Rasterize(FineSpan,CoarseTile.Key,VoxelMeters);
-            PopRows[Lod]=ComparePop(CoarseGrid,FineGrid,CoarseTile.Key,VoxelMeters,
+            std::vector<const FStandaloneCpuTile*> FineBeforePointers,FineAfterPointers;
+            FineBeforePointers.reserve(FineBeforeTiles.size());FineAfterPointers.reserve(FineAfterTiles.size());
+            for(const auto& Tile:FineBeforeTiles)FineBeforePointers.push_back(&Tile);
+            for(const auto& Tile:FineAfterTiles)FineAfterPointers.push_back(&Tile);
+            const auto FineBeforeSpan=std::span<const FStandaloneCpuTile* const>(
+                FineBeforePointers.data(),FineBeforePointers.size());
+            const auto FineAfterSpan=std::span<const FStandaloneCpuTile* const>(
+                FineAfterPointers.data(),FineAfterPointers.size());
+            const FHeightGrid FineBeforeGrid=Rasterize(FineBeforeSpan,CoarseTile.Key,VoxelMeters);
+            const FHeightGrid FineAfterGrid=Rasterize(FineAfterSpan,CoarseTile.Key,VoxelMeters);
+            const FPopRow PopBefore=ComparePop(BaselineGrid,FineBeforeGrid,CoarseTile.Key,VoxelMeters,
                Budgets[Lod],Assembly,View);
-            const FPopRow& Pop=PopRows[Lod];
-            const bool PopPass=Pop.Valid&&Pop.Cracks==0&&Pop.Floating==0&&Pop.Maximum<=1.0;
+            const FPopRow PopAfter=ComparePop(CoarseGrid,FineAfterGrid,CoarseTile.Key,VoxelMeters,
+                Budgets[Lod],Assembly,View);
+            const bool PopPass=PopNotWorseAtAnySample(PopBefore,PopAfter);
            GatePass=GatePass&&PopPass;
-            std::printf("[ScreenSpaceSwap] lod=%d_to_%d samples=%llu normal_px_p50=%.4f p99=%.4f max=%.4f vertical_px_p50=%.4f p99=%.4f max=%.4f max_normal_m=%.6f max_xyz_m=(%.3f,%.3f,%.3f) max_slope_deg=%.2f cracks=%llu floating=%llu status=%s\n",
-                Lod,Lod-1,static_cast<unsigned long long>(Pop.Samples),
-                Pop.P50,Pop.P99,Pop.Maximum,Pop.VerticalP50,Pop.VerticalP99,Pop.VerticalMaximum,
-                Pop.MaximumNormalDistanceMeters,Pop.MaximumX,Pop.MaximumY,
-                Pop.MaximumDisplayedZ,
-                Pop.MaximumSlopeDegrees,static_cast<unsigned long long>(Pop.Cracks),
-                static_cast<unsigned long long>(Pop.Floating),
+            std::printf("[ScreenSpaceSwap] swap=%d_to_%d distance_m=%.3f samples_before=%llu pop_before_px_p50=%.4f p99=%.4f max=%.4f pop_after_px_p50=%.4f p99=%.4f max=%.4f missing_root_samples_before=%llu after=%llu status=%s\n",
+                Lod,Lod-1,Distances[Lod],static_cast<unsigned long long>(PopBefore.Samples),
+                PopBefore.P50,PopBefore.P99,PopBefore.Maximum,PopAfter.P50,PopAfter.P99,PopAfter.Maximum,
+                static_cast<unsigned long long>(PopBefore.Cracks),static_cast<unsigned long long>(PopAfter.Cracks),
                PopPass?"PASS":"REJECT");
-            PrintSlopeTail("swap",Lod,Pop.SlopeSamples,Pop.SlopeP99,Pop.SlopeMaximum);

-            const FHeightGrid MissingFineGrid(CoarseGrid.Side,CoarseGrid.MinimumX,
-                CoarseGrid.MaximumX,CoarseGrid.MinimumY,CoarseGrid.MaximumY);
-            const FPopRow MissingFineError=ComparePop(CoarseGrid,MissingFineGrid,
+            const FHeightGrid MissingFineGrid(BaselineGrid.Side,BaselineGrid.MinimumX,
+                BaselineGrid.MaximumX,BaselineGrid.MinimumY,BaselineGrid.MaximumY);
+            const FPopRow MissingFineError=ComparePop(BaselineGrid,MissingFineGrid,
                CoarseTile.Key,VoxelMeters,Budgets[Lod],Assembly,View);
            const bool CrackRejected=MissingFineError.Cracks>0&&MissingFineError.Maximum>1.0;
            FaultControlsPass=FaultControlsPass&&CrackRejected;
-            GatePass=GatePass&&FaultControlsPass;
            std::printf("[ScreenSpaceFaultInjection] lod=%d case=missing-fine-ring-surface cracks=%llu max_px=%.4f status=%s\n",
                Lod,static_cast<unsigned long long>(MissingFineError.Cracks),
                MissingFineError.Maximum,CrackRejected?"REJECTED_AS_REQUIRED":"GATE_FALSE_NEGATIVE");
@@ -695,25 +851,170 @@ namespace StandaloneScreenSpaceGate
            const auto CheckNegative=[&](const char* Name,std::uint32_t Drop,std::uint32_t Stride)
            {
                FStandaloneCpuTile Bad=Streamer.GenerateDiagnostic(
-                    CoarseTile.Key,Drop,Stride,true);
+                    CoarseTile.Key,Drop,Stride,true,nullptr,true);
                const FStandaloneCpuTile* BadPointer=&Bad;
                const std::span<const FStandaloneCpuTile* const> BadSpan(&BadPointer,1);
                const FHeightGrid BadGrid=Rasterize(BadSpan,Bad.Key,VoxelMeters);
-                const FErrorRow BadError=CompareToReference(BadGrid,ExactGrid,
-                    CoarseTile.Key,VoxelMeters,Budgets[Lod],Assembly,View);
-                const bool Rejected=BadError.Missing>0||BadError.Floating>0
-                    ||BadError.Samples<16||BadError.Maximum>1.0;
+                const FMeshComparisonRow BadError=CompareMeshes(BaselineGrid,BadGrid,
+                    CoarseTile.Key,VoxelMeters,Budgets[Lod],View);
+                const bool Rejected=BadError.Holes>0||BadError.Floating>0||BadError.Cracks>0
+                    ||BadError.Geometry.Samples<16||BadError.Geometry.Maximum>1.0
+                    ||BadError.ShadeMaximum>ShadeLimit;
                NegativeControlsPass=NegativeControlsPass&&Rejected;
-                std::printf("[ScreenSpaceNegative] lod=%d case=%s p50_px=%.4f p99_px=%.4f max_px=%.4f missing=%llu floating=%llu status=%s\n",
-                    Lod,Name,BadError.P50,BadError.P99,BadError.Maximum,
-                    static_cast<unsigned long long>(BadError.Missing),
+                std::printf("[ScreenSpaceNegative] lod=%d case=%s p50_px=%.4f p99_px=%.4f max_px=%.4f shade_max=%.6f holes=%llu cracks=%llu floating=%llu status=%s\n",
+                    Lod,Name,BadError.Geometry.P50,BadError.Geometry.P99,BadError.Geometry.Maximum,
+                    BadError.ShadeMaximum,static_cast<unsigned long long>(BadError.Holes),
+                    static_cast<unsigned long long>(BadError.Cracks),
                    static_cast<unsigned long long>(BadError.Floating),
                    Rejected?"REJECTED_AS_REQUIRED":"GATE_FALSE_NEGATIVE");
            };
            CheckNegative("s13-global-octave-drop",1,1);
            CheckNegative("stride-2-column-interpolation",0,2);
-            GatePass=GatePass&&NegativeControlsPass;
+            GatePass=GatePass&&FaultControlsPass&&NegativeControlsPass;
        }
+
+        struct FCoverageRow
+        {
+            std::uint64_t Tiles=0,Holes=0,Cracks=0,Floating=0,MaterialMismatches=0;
+            std::vector<double> GeometryPixels,ShadeValues,NormalAngles;
+        };
+        std::array<FCoverageRow,9> Coverage;
+        for(const FVoxelTileKey& Key:DesiredKeys)
+        {
+            const int Lod=Key.Level;
+            if(Lod<3||Lod>MaxLod||Lod>=9)continue;
+            FStandaloneCpuTile BaselineTile=Streamer.GenerateDiagnostic(
+                Key,0,1,true,&BaselineOptions,true);
+            FStandaloneCpuTile CandidateTile=Streamer.GenerateDiagnostic(
+                Key,0,1,true,&CandidateOptions,true);
+            const FStandaloneCpuTile* BaselinePointer=&BaselineTile;
+            const FStandaloneCpuTile* CandidatePointer=&CandidateTile;
+            const std::span<const FStandaloneCpuTile* const> BaselineSpan(&BaselinePointer,1);
+            const std::span<const FStandaloneCpuTile* const> CandidateSpan(&CandidatePointer,1);
+            const FHeightGrid BaselineGrid=Rasterize(BaselineSpan,Key,VoxelMeters);
+            const FHeightGrid CandidateGrid=Rasterize(CandidateSpan,Key,VoxelMeters);
+            const FMeshComparisonRow Delta=CompareMeshes(BaselineGrid,CandidateGrid,
+                Key,VoxelMeters,Budgets[Lod],View);
+            auto& Row=Coverage[Lod];
+            ++Row.Tiles;
+            Row.Holes+=Delta.Holes;Row.Cracks+=Delta.Cracks;Row.Floating+=Delta.Floating;
+            Row.MaterialMismatches+=Delta.MaterialMismatches;
+            Row.GeometryPixels.insert(Row.GeometryPixels.end(),
+                Delta.GeometryPixels.begin(),Delta.GeometryPixels.end());
+            Row.ShadeValues.insert(Row.ShadeValues.end(),Delta.ShadeValues.begin(),Delta.ShadeValues.end());
+            Row.NormalAngles.insert(Row.NormalAngles.end(),Delta.NormalAngles.begin(),Delta.NormalAngles.end());
+        }
+        for(int Lod=3;Lod<=MaxLod&&Lod<9;++Lod)
+        {
+            auto& Row=Coverage[Lod];
+            const double GeometryP50=Percentile(Row.GeometryPixels,0.50);
+            const double GeometryP99=Percentile(Row.GeometryPixels,0.99);
+            const double GeometryMaximum=Row.GeometryPixels.empty()?0.0
+                :*std::max_element(Row.GeometryPixels.begin(),Row.GeometryPixels.end());
+            const double ShadeP50=Percentile(Row.ShadeValues,0.50);
+            const double ShadeP99=Percentile(Row.ShadeValues,0.99);
+            const double ShadeMaximum=Row.ShadeValues.empty()?0.0
+                :*std::max_element(Row.ShadeValues.begin(),Row.ShadeValues.end());
+            const double NormalP50=Percentile(Row.NormalAngles,0.50);
+            const double NormalP99=Percentile(Row.NormalAngles,0.99);
+            const double NormalMaximum=Row.NormalAngles.empty()?0.0
+                :*std::max_element(Row.NormalAngles.begin(),Row.NormalAngles.end());
+            const bool LodPass=Row.Tiles>0&&Row.GeometryPixels.size()>=16
+                &&GeometryMaximum<=1.0&&ShadeMaximum<=ShadeLimit
+                &&Row.Holes==0&&Row.Cracks==0&&Row.Floating==0;
+            GatePass=GatePass&&LodPass;
+            std::printf("[ScreenSpaceGateCoverageLOD] lod=%d tiles=%llu geometry_samples=%llu geometry_px_p50=%.4f p99=%.4f max=%.4f shading_delta_p50=%.6f p99=%.6f max=%.6f normal_deg_p50=%.4f p99=%.4f max=%.4f material_mismatch=%llu holes=%llu cracks=%llu floating=%llu status=%s\n",
+                Lod,static_cast<unsigned long long>(Row.Tiles),
+                static_cast<unsigned long long>(Row.GeometryPixels.size()),
+                GeometryP50,GeometryP99,GeometryMaximum,ShadeP50,ShadeP99,ShadeMaximum,
+                NormalP50,NormalP99,NormalMaximum,
+                static_cast<unsigned long long>(Row.MaterialMismatches),
+                static_cast<unsigned long long>(Row.Holes),
+                static_cast<unsigned long long>(Row.Cracks),
+                static_cast<unsigned long long>(Row.Floating),LodPass?"PASS":"REJECT");
+        }
+
+        std::uint64_t RepairOpportunities=0,BaselineWallHoles=0,BaselineWallFloating=0;
+        std::uint64_t CandidateWallRays=0,CandidateWallHoles=0,CandidateWallFloating=0;
+        std::vector<std::uint64_t> BaselineHoleIds,CandidateHoleIds;
+        std::vector<std::uint64_t> BaselineFloatingIds,CandidateFloatingIds;
+        std::vector<std::uint64_t> CandidatePanelRemovalHoleIds;
+        bool bRanPanelRemovalControl=false;
+        for(const FVoxelTileKey& Key:DesiredKeys)
+        {
+            if(Key.Level<6||Key.Level>8)continue;
+            VoxelForgeCore::TileGenerationOptions NoPanelBaseline=BaselineOptions;
+            NoPanelBaseline.diagnosticRemoveFarConnectorPanels=true;
+            NoPanelBaseline.diagnosticAuditFarConnectorCoverage=true;
+            const FStandaloneCpuTile BaseNoPanels=Streamer.GenerateDiagnostic(Key,0,1,true,&NoPanelBaseline);
+            RepairOpportunities+=BaseNoPanels.CoreDiagnostics.farConnectorAuditHoles;
+
+            VoxelForgeCore::TileGenerationOptions AuditedBaseline=BaselineOptions;
+            AuditedBaseline.diagnosticAuditFarConnectorCoverage=true;
+            const FStandaloneCpuTile BaseRepaired=Streamer.GenerateDiagnostic(Key,0,1,true,&AuditedBaseline);
+            BaselineWallHoles+=BaseRepaired.CoreDiagnostics.farConnectorAuditHoles;
+            BaselineWallFloating+=BaseRepaired.CoreDiagnostics.farConnectorAuditFloating;
+            BaselineHoleIds.insert(BaselineHoleIds.end(),
+                BaseRepaired.CoreDiagnostics.farConnectorAuditHoleIds.begin(),
+                BaseRepaired.CoreDiagnostics.farConnectorAuditHoleIds.end());
+            BaselineFloatingIds.insert(BaselineFloatingIds.end(),
+                BaseRepaired.CoreDiagnostics.farConnectorAuditFloatingIds.begin(),
+                BaseRepaired.CoreDiagnostics.farConnectorAuditFloatingIds.end());
+
+            VoxelForgeCore::TileGenerationOptions AuditedCandidate=CandidateOptions;
+            AuditedCandidate.diagnosticAuditFarConnectorCoverage=true;
+            const FStandaloneCpuTile CandidateRepaired=Streamer.GenerateDiagnostic(Key,0,1,true,&AuditedCandidate);
+            CandidateWallRays+=CandidateRepaired.CoreDiagnostics.farConnectorAuditRays;
+            CandidateWallHoles+=CandidateRepaired.CoreDiagnostics.farConnectorAuditHoles;
+            CandidateWallFloating+=CandidateRepaired.CoreDiagnostics.farConnectorAuditFloating;
+            CandidateHoleIds.insert(CandidateHoleIds.end(),
+                CandidateRepaired.CoreDiagnostics.farConnectorAuditHoleIds.begin(),
+                CandidateRepaired.CoreDiagnostics.farConnectorAuditHoleIds.end());
+            CandidateFloatingIds.insert(CandidateFloatingIds.end(),
+                CandidateRepaired.CoreDiagnostics.farConnectorAuditFloatingIds.begin(),
+                CandidateRepaired.CoreDiagnostics.farConnectorAuditFloatingIds.end());
+
+            if(!bRanPanelRemovalControl&&BaseNoPanels.CoreDiagnostics.farConnectorAuditHoles>0)
+            {
+                AuditedCandidate.diagnosticRemoveFarConnectorPanels=true;
+                const FStandaloneCpuTile CandidateNoPanels=Streamer.GenerateDiagnostic(
+                    Key,0,1,true,&AuditedCandidate);
+                CandidatePanelRemovalHoleIds=CandidateNoPanels.CoreDiagnostics.farConnectorAuditHoleIds;
+                bRanPanelRemovalControl=true;
+            }
+        }
+        std::sort(BaselineHoleIds.begin(),BaselineHoleIds.end());
+        std::sort(CandidateHoleIds.begin(),CandidateHoleIds.end());
+        std::sort(BaselineFloatingIds.begin(),BaselineFloatingIds.end());
+        std::sort(CandidateFloatingIds.begin(),CandidateFloatingIds.end());
+        const auto IsSubset=[](const std::vector<std::uint64_t>& A,const std::vector<std::uint64_t>& B)
+        {return std::includes(B.begin(),B.end(),A.begin(),A.end());};
+        std::sort(CandidatePanelRemovalHoleIds.begin(),CandidatePanelRemovalHoleIds.end());
+        const bool bNoNewHoles=IsSubset(CandidateHoleIds,BaselineHoleIds);
+        const bool bNoNewFloating=IsSubset(CandidateFloatingIds,BaselineFloatingIds);
+        const bool bPanelRemovalDetected=bRanPanelRemovalControl
+            &&!IsSubset(CandidatePanelRemovalHoleIds,CandidateHoleIds);
+        std::vector<std::uint64_t> NewHoleIds,NewFloatingIds,PanelRemovalNewHoleIds;
+        std::set_difference(CandidateHoleIds.begin(),CandidateHoleIds.end(),
+            BaselineHoleIds.begin(),BaselineHoleIds.end(),std::back_inserter(NewHoleIds));
+        std::set_difference(CandidateFloatingIds.begin(),CandidateFloatingIds.end(),
+            BaselineFloatingIds.begin(),BaselineFloatingIds.end(),std::back_inserter(NewFloatingIds));
+        std::set_difference(CandidatePanelRemovalHoleIds.begin(),CandidatePanelRemovalHoleIds.end(),
+            CandidateHoleIds.begin(),CandidateHoleIds.end(),std::back_inserter(PanelRemovalNewHoleIds));
+        const bool bRepairRowsPass=RepairOpportunities>0&&bNoNewHoles&&bNoNewFloating
+            &&bPanelRemovalDetected;
+        GatePass=GatePass&&bRepairRowsPass;
+        std::printf("[ScreenSpaceConnectorGate] lods=6..8 baseline_missing_ray_stations=%llu candidate_audited_rays=%llu baseline_holes=%llu candidate_holes=%llu new_holes=%llu baseline_floating=%llu candidate_floating=%llu new_floating=%llu panel_removal_new_holes=%llu status=%s\n",
+            static_cast<unsigned long long>(RepairOpportunities),
+            static_cast<unsigned long long>(CandidateWallRays),
+            static_cast<unsigned long long>(BaselineWallHoles),
+            static_cast<unsigned long long>(CandidateWallHoles),
+            static_cast<unsigned long long>(NewHoleIds.size()),
+            static_cast<unsigned long long>(BaselineWallFloating),
+            static_cast<unsigned long long>(CandidateWallFloating),
+            static_cast<unsigned long long>(NewFloatingIds.size()),
+            static_cast<unsigned long long>(PanelRemovalNewHoleIds.size()),
+            bRepairRowsPass?"PASS":"REJECT");
        std::printf("[ScreenSpaceGateResult] status=%s\n",GatePass?"PASS":"REJECT");
        return GatePass;
    }
@@ -412,6 +412,7 @@ namespace StandaloneStreamBenchmark
        FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
            bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape,bProfileColumnOverlap,
            FarHorizonLOD8InteriorStepVoxels,bUseSharedColumnCache);
+        Streamer.SetDisplayAttributeCaptureEnabled(bScreenSpaceGate);
        Streamer.SetUniformBlockProofAuditEnabled(bAuditUniformBlockProofs);
        if(bScreenSpaceGate||bReportLodWorkProfile)Streamer.SetMesherStageProfilingEnabled(true);
        const auto StreamStart=Clock::now();
@@ -1480,7 +1481,7 @@ namespace StandaloneStreamBenchmark
        {
            if(Assembly)
                bScreenSpaceGatePassing=StandaloneScreenSpaceGate::Run(GateSampleTiles,
-                    Streamer,*Assembly,ClosestDisplayDistances,World.CoreVoxelSizeMicrons,
+                    Streamer,Desired.Tiles,*Assembly,ClosestDisplayDistances,World.CoreVoxelSizeMicrons,
                    World.MaxClipLevel,PixelBudgetsSubvoxels,CameraYawDegrees,
                    CameraPitchDegrees);
            else
@@ -43,9 +43,11 @@ struct FStandaloneCpuTile
    FVoxelTileKey Key;
    uint64 RequestedCrossing=0;
    std::vector<FStandaloneCpuVertex> Vertices;
+    std::vector<std::array<uint8,4>> VertexColors;
    std::vector<uint32> Indices;
    std::vector<uint8> TriangleSkirtFaceMasks;
    uint32 SurfaceVertexCount=0;
+    uint32 CeilingTriangleCount=0;
    uint32 SkirtTriangleCount=0;
    uint64 DensitySamples=0;
    double WorkerSeconds=0.0;
@@ -653,12 +655,17 @@ public:
    {bProfileMesherStages=Enabled;}
    void SetUniformBlockProofAuditEnabled(bool Enabled)
    {bAuditUniformBlockProofs=Enabled;}
+    void SetDisplayAttributeCaptureEnabled(bool Enabled)
+    {bCaptureDisplayAttributes=Enabled;}
    FStandaloneCpuTile GenerateDiagnostic(const FVoxelTileKey& Key,
        std::uint32_t GlobalOctaveDrop=0,std::uint32_t CellStride=1,
-        bool ForceGenerate=false)
+        bool ForceGenerate=false,
+        const VoxelForgeCore::TileGenerationOptions* FarDisplayOverride=nullptr,
+        bool CaptureDisplayAttributes=false)
    {
        FStandaloneTileJob Job;Job.Key=Key;Job.StartedAt=FClock::now();Job.QueuedAt=Job.StartedAt;
-        return Generate(Job,GlobalOctaveDrop,CellStride,ForceGenerate);
+        return Generate(Job,GlobalOctaveDrop,CellStride,ForceGenerate,FarDisplayOverride,
+            CaptureDisplayAttributes);
    }

 private:
@@ -778,7 +785,9 @@ private:
    }
    FStandaloneCpuTile Generate(const FStandaloneTileJob& Job,
        std::uint32_t DiagnosticGlobalOctaveDrop=0,std::uint32_t DiagnosticCellStride=1,
-        bool ForceGenerate=false)
+        bool ForceGenerate=false,
+        const VoxelForgeCore::TileGenerationOptions* FarDisplayOverride=nullptr,
+        bool CaptureDisplayAttributes=false)
    {
        const auto StartTime=Job.StartedAt;
        FStandaloneCpuTile Out;Out.Key=Job.Key;Out.RequestedCrossing=Job.RequestedCrossing;
@@ -829,6 +838,18 @@ private:
            Options.diagnosticCellStride=std::max<std::uint32_t>(1,DiagnosticCellStride);
            Options.diagnosticColumnInterpolationStride=
                std::max<std::uint32_t>(1,DiagnosticCellStride);
+            if(FarDisplayOverride)
+            {
+                Options.overrideFarDisplayMesh=FarDisplayOverride->overrideFarDisplayMesh;
+                Options.farDisplayGeometryBudgetMillipixels=FarDisplayOverride->farDisplayGeometryBudgetMillipixels;
+                Options.farRefinementGridScale=FarDisplayOverride->farRefinementGridScale;
+                Options.farRefinementLodMask=FarDisplayOverride->farRefinementLodMask;
+                Options.farConnectorStationScale=FarDisplayOverride->farConnectorStationScale;
+                Options.farConnectorRayMask=FarDisplayOverride->farConnectorRayMask;
+                Options.farConnectorReuseStationRadii=FarDisplayOverride->farConnectorReuseStationRadii;
+                Options.diagnosticRemoveFarConnectorPanels=FarDisplayOverride->diagnosticRemoveFarConnectorPanels;
+                Options.diagnosticAuditFarConnectorCoverage=FarDisplayOverride->diagnosticAuditFarConnectorCoverage;
+            }
            std::string Error;
            auto Result=CoreWorld->generateTile(
                {{Job.Key.Coord.X,Job.Key.Coord.Y,Job.Key.Coord.Z},Job.Key.Level},Options,Error);
@@ -842,6 +863,7 @@ private:
            Out.DensitySamples=Result->densitySampleCount;
            Out.CoreDiagnostics=Result->diagnostics;
            Out.SurfaceVertexCount=Result->groups.surfaceVertexCount;
+            Out.CeilingTriangleCount=Result->groups.ceilingTriangleCount;
            Out.SkirtTriangleCount=Result->groups.skirtTriangleCount;
            Out.MeshPayloadAllocatedBytes=Result->meshPayloadAllocatedBytes;
            Out.DensityHash=Result->densityHash;Out.MeshHash=Result->meshHash;
@@ -849,12 +871,18 @@ private:
            Out.bHasDensityHash=Result->hasDensityHash;Out.bHasMeshHash=Result->hasMeshHash;
            Out.bHasPayloadHash=Result->hasPayloadHash;Out.bHasTopologyHash=Result->hasTopologyHash;
            Out.Vertices.reserve(Result->vertices.size());
+            const bool bCaptureAttributes=CaptureDisplayAttributes||bCaptureDisplayAttributes;
+            if(bCaptureAttributes)Out.VertexColors.reserve(Result->vertices.size());
            for(const auto& Vertex:Result->vertices)
+            {
                Out.Vertices.push_back({
                    {static_cast<float>(Vertex.position.x*0.01),static_cast<float>(Vertex.position.y*0.01),
                     static_cast<float>(Vertex.position.z*0.01)},
                    {static_cast<float>(Vertex.normal.x),static_cast<float>(Vertex.normal.y),
                     static_cast<float>(Vertex.normal.z)}});
+                if(bCaptureAttributes)
+                    Out.VertexColors.push_back({Vertex.color.r,Vertex.color.g,Vertex.color.b,Vertex.color.a});
+            }
            Out.Indices=std::move(Result->indices);
            Out.TriangleSkirtFaceMasks=std::move(Result->skirtFaceMasks);
            if(bProfile)
@@ -1001,6 +1029,7 @@ private:
    bool bSkipUV=false;
    bool bSkipColors=false;
    bool bCaptureColumnCoordinates=false;
+    bool bCaptureDisplayAttributes=false;
    bool bSharedColumnCache=true;
    int32 Lod8HorizonInteriorStepVoxels=0;
    bool bProfileMesherStages=false;
@@ -30,6 +30,34 @@ namespace StandaloneWorldAssemblyPrototype
        return std::max<std::int64_t>(1,WorldAssemblyFixed(wavelength));
    }

+    inline bool ApplyFarDisplayMeshDeclaration(const VFJson::Value& root,
+        VoxelForgeCore::WorldAssemblyRecipeV1& recipe,std::string& error)
+    {
+        const VFJson::Value& declaration=root.Get("far_display_mesh");
+        if(std::holds_alternative<std::nullptr_t>(declaration.Data))return true;
+        if(!declaration.IsObject())
+        {error="far_display_mesh must be an object when declared";return false;}
+        const auto ReadUnsigned=[&](const char* key,std::uint32_t& output)
+        {
+            const VFJson::Value& value=declaration.Get(key);
+            if(!value.IsNumber()||!std::isfinite(value.Number())||value.Number()<0.0
+                ||value.Number()>static_cast<double>(UINT32_MAX)
+                ||std::floor(value.Number())!=value.Number())return false;
+            output=static_cast<std::uint32_t>(value.Number());return true;
+        };
+        if(!ReadUnsigned("geometry_budget_millipixels",recipe.farDisplayGeometryBudgetMillipixels)
+            ||!ReadUnsigned("refinement_grid_scale",recipe.farRefinementGridScale)
+            ||!ReadUnsigned("refinement_lod_mask",recipe.farRefinementLodMask)
+            ||!ReadUnsigned("connector_station_scale",recipe.farConnectorStationScale)
+            ||!ReadUnsigned("connector_ray_mask",recipe.farConnectorRayMask))
+        {error="far_display_mesh declaration has a missing or non-integer parameter";return false;}
+        const VFJson::Value& reuse=declaration.Get("connector_reuse_station_radii");
+        if(!std::holds_alternative<bool>(reuse.Data))
+        {error="far_display_mesh connector_reuse_station_radii must be boolean";return false;}
+        recipe.farConnectorReuseStationRadii=std::get<bool>(reuse.Data);
+        return true;
+    }
+
    inline uint64 WorldAssemblyFeatureId(uint32 seed,int64 x,int64 y,uint32 kind)
    {
        uint64 hash=14695981039346656037ull;
@@ -223,6 +251,7 @@ namespace StandaloneWorldAssemblyPrototype
        recipe.biomeClimateReliefWavelengthSubvoxels=WorldAssemblyWavelength(map.ReliefFrequency,3333.0);
        recipe.biomeClimateMoistureWavelengthSubvoxels=WorldAssemblyWavelength(map.MoistureFrequency,2500.0);
        recipe.biomeClimateReliefContrastQ16=WorldAssemblyQ16(map.ReliefContrast);
+        if(!ApplyFarDisplayMeshDeclaration(root,recipe,error))return false;
        const auto makeProfile=[&](uint32 stableId,const FSurfaceGenerationParams& params,
                                   const FBiomeResolved* climate)
        {