wip(assembler): M1 round 4 -- cap rebuilt (no hiding), sub-voxel audit, routes + mesh-free queries

Luna, M1 round 4 (resumed after the night stop):
- Cliff: sub-voxel audit (29,929 half-voxel XY columns, min run 3.75 voxels, 0 subvoxel runs;
  old taper control exposes 20,963) and a root-line shelf at the two-voxel minimum.
- Horizon slab = aliased LOD8 cap ceiling. The first fix hid the ceiling at LOD8 (challenged:
  enclosed, interior-lit strates); now the LOD8 cap is rebuilt deterministically from the
  native heightfield, skirts preserved; looking up and out shows the cap present.
- Routes: review manifest with 33 stable-ID route points + capsule/support constraints; capsule
  sweep 0 blocked samples / 0 unsupported centres, negative control detected.
- Server path: World::densityAt answers without render meshes. Physics cooking not available
  standalone.
- Hashes (evaluator + 2,226-tile stream) identical at W1/W8/W16. LOD8: 4.446 s for 529 tiles,
  14.25 M field calls, 165 unknown tiles.
- Captures at 60 fps cap + vsync (owner's GPU coil whine). One cliff probe crossed the ~8 GB
  guard (7.69 GiB) and was stopped before capturing.
My review: cap view matches legacy closely, no slab; native cliff is a clean attached ledge
(cleaner than legacy); a few small spikes on the ridge top.

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

Standalone/Source/StandaloneViewer.cpp

@@ -7102,6 +7102,9 @@ float3 Lit=Rock*(Ambient+0.88*Diffuse)+float3(0.50,0.69,0.82)*Head*0.75;
         uint64 WholeFloatFieldCalls=0,WholeLatticeFieldCalls=0,WholeUnclampedFieldCalls=0;
         double WholeClassificationMilliseconds=0.0,WholeColumnComputeMilliseconds=0.0;
         double WholeMeshingMilliseconds=0.0;
+        uint64 WholeCapRefinedTiles=0,WholeCapRefinedCells=0,WholeCapRefinedTriangles=0;
+        int32 WholeCapTileCoordMin[3]={INT32_MAX,INT32_MAX,INT32_MAX};
+        int32 WholeCapTileCoordMax[3]={INT32_MIN,INT32_MIN,INT32_MIN};
         uint64 WholeSolidBoxesByLevel[MaxLevels+1]{},WholeAirBoxesByLevel[MaxLevels+1]{};
         uint64 WholeMixedBoxesByLevel[MaxLevels+1]{},WholeUnknownBoxesByLevel[MaxLevels+1]{};
         uint64 WholeFieldCallsByLevel[MaxLevels+1]{},WholeColumnHitsByLevel[MaxLevels+1]{};
@@ -7173,6 +7176,17 @@ float3 Lit=Rock*(Ambient+0.88*Diffuse)+float3(0.50,0.69,0.82)*Head*0.75;
                     WholeColumnHits+=Tile.CoreDiagnostics.columnCacheHits;
                     WholeColumnMisses+=Tile.CoreDiagnostics.columnCacheMisses;
                     WholeTileSkips+=Tile.CoreDiagnostics.meshingSkipped?1u:0u;
+                    WholeCapRefinedTiles+=Tile.CoreDiagnostics.capRefined?1u:0u;
+                    WholeCapRefinedCells+=Tile.CoreDiagnostics.capRefinedCells;
+                    WholeCapRefinedTriangles+=Tile.CoreDiagnostics.capRefinedTriangles;
+                    if(Tile.CoreDiagnostics.capRefined)
+                        for(int32 Axis=0;Axis<3;++Axis)
+                        {
+                            WholeCapTileCoordMin[Axis]=std::min(WholeCapTileCoordMin[Axis],
+                                (&Tile.Key.Coord.X)[Axis]);
+                            WholeCapTileCoordMax[Axis]=std::max(WholeCapTileCoordMax[Axis],
+                                (&Tile.Key.Coord.X)[Axis]);
+                        }
                     WholeClassificationMilliseconds+=Tile.CoreDiagnostics.classificationMilliseconds;
                     WholeColumnComputeMilliseconds+=Tile.CoreDiagnostics.columnComputeMilliseconds;
                     WholeMeshingMilliseconds+=Tile.CoreDiagnostics.meshingMilliseconds;
@@ -7441,6 +7455,15 @@ float3 Lit=Rock*(Ambient+0.88*Diffuse)+float3(0.50,0.69,0.82)*Head*0.75;
                 static_cast<unsigned long long>(WholeColumnMisses),
                 WholeColumnComputeMilliseconds,WholeClassificationMilliseconds,
                 WholeMeshingMilliseconds);
+        if(CoreWorld)
+            std::printf("[WorldAssemblerLod8Cap] grid_step_voxels=128 refined_tiles=%llu valid_grid_cells=%llu generated_triangles=%llu\n",
+                static_cast<unsigned long long>(WholeCapRefinedTiles),
+                static_cast<unsigned long long>(WholeCapRefinedCells),
+                static_cast<unsigned long long>(WholeCapRefinedTriangles));
+        if(CoreWorld&&WholeCapRefinedTiles>0)
+            std::printf("[WorldAssemblerLod8CapTiles] lod=8 extent_voxels=8192 coord_min=(%d,%d,%d) coord_max=(%d,%d,%d)\n",
+                WholeCapTileCoordMin[0],WholeCapTileCoordMin[1],WholeCapTileCoordMin[2],
+                WholeCapTileCoordMax[0],WholeCapTileCoordMax[1],WholeCapTileCoordMax[2]);
         if(CoreWorld)
             for(int32 Level=0;Level<=MaxLevels;++Level)
                 if(TilesByLevel[Level]>0)
@@ -8911,7 +8934,8 @@ int main(int Argc,char** Argv)
     for(int32 I=1;I<Argc;++I)
     {if(!JoinedCommandLine.empty())JoinedCommandLine.push_back(' ');JoinedCommandLine+=Argv[I];}
     FCommandLine::Set(JoinedCommandLine);
-    int32 BenchmarkLevel=-1,BenchmarkCount=64,StreamBenchmarkMaxLevel=-1;
+    int32 BenchmarkLevel=-1,BenchmarkCount=64,StreamBenchmarkMaxLevel=-1,FrameLimitHz=60;
+    bool bFrameLimitSpecified=false;
     int32 MaxClipLevelOverride=-1;
     int32 ShapeCompareLevel=-1,ShapeCompareTileLimit=0;
     std::string ShapeCompareArea="unlabeled";
@@ -8941,6 +8965,8 @@ int main(int Argc,char** Argv)
         const std::string_view Arg=Argv[I];
         if(Arg.starts_with("--capture="))App.CapturePath=std::string(Arg.substr(10));
         else if(Arg=="--no-vsync")App.bDisableVSync=true;
+        else if(Arg.starts_with("--frame-limit="))
+        {FrameLimitHz=std::clamp(std::atoi(std::string(Arg.substr(14)).c_str()),1,60);bFrameLimitSpecified=true;}
         else if(Arg=="--blocking-startup-present")App.bForceBlockingStartupPresent=true;
         else if(Arg=="--cpu-frame-before-gpu")App.bPresentCpuFrameBeforeGpu=true;
         else if(Arg=="--hold-cpu-frame-during-gpu-warmup")
@@ -9128,6 +9154,8 @@ int main(int Argc,char** Argv)
         }
         else if(!Arg.empty()&&Arg.front()!='-')App.DataPath=std::string(Arg);
     }
+    std::printf("[FrameLimiter] target_fps=%d maximum=true vsync=%s source=%s\n",FrameLimitHz,
+        App.bDisableVSync?"off":"on",bFrameLimitSpecified?"argument":"default");
     if(App.bCaptureOnlyTile&&App.bGpuFarEnabled)
     {
         // A single far-tile probe may have no CPU fallback batch to present.
@@ -9356,10 +9384,21 @@ int main(int Argc,char** Argv)
             std::chrono::steady_clock::now()-ColdProcessStart).count());
     App.StartGeneration();
     MSG Message{};
+    const auto FramePeriod=std::chrono::duration<double>(1.0/static_cast<double>(FrameLimitHz));
+    auto NextFrameStart=std::chrono::steady_clock::now();
     while(Message.message!=WM_QUIT)
     {
         if(PeekMessage(&Message,nullptr,0,0,PM_REMOVE)){TranslateMessage(&Message);DispatchMessage(&Message);}
-        else App.Draw();
+        else
+        {
+            const auto Now=std::chrono::steady_clock::now();
+            if(Now<NextFrameStart)std::this_thread::sleep_until(NextFrameStart);
+            const auto FrameStart=std::chrono::steady_clock::now();
+            App.Draw();
+            NextFrameStart=FrameStart+std::chrono::duration_cast<std::chrono::steady_clock::duration>(FramePeriod);
+            const auto FrameEnd=std::chrono::steady_clock::now();
+            if(NextFrameStart<FrameEnd)NextFrameStart=FrameEnd;
+        }
     }
     GApp=nullptr;
     return 0;

Standalone/Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp

@@ -326,12 +326,16 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
                 if (!Col)
                 {
                     float TerrainZ = 0.0f, CeilSurf = 0.0f;
-                    const bool bSurf = Generator->GetSurfaceHeightAt(
-                            (float)(MemoKey.X * Step), (float)(MemoKey.Y * Step), MemoKey.Z,
-                            TerrainZ, CeilSurf)
-                        || Generator->GetSurfaceHeightAt(
-                            (float)(MemoKey.X * Step), (float)(MemoKey.Y * Step), MemoKey.Z - 1,
-                            TerrainZ, CeilSurf);
+                    bool bSurf=ShapeWorldContext&&ShapeWorldContext->GetNativeSurfaceHeightsAt(
+                        static_cast<float>(MemoKey.X*Step),static_cast<float>(MemoKey.Y*Step),
+                        MemoKey.Z,TerrainZ,CeilSurf);
+                    if(!bSurf)
+                        bSurf=Generator->GetSurfaceHeightAt(
+                                (float)(MemoKey.X * Step), (float)(MemoKey.Y * Step), MemoKey.Z,
+                                TerrainZ, CeilSurf)
+                            || Generator->GetSurfaceHeightAt(
+                                (float)(MemoKey.X * Step), (float)(MemoKey.Y * Step), MemoKey.Z - 1,
+                                TerrainZ, CeilSurf);
                     Col = &SurfColMemo.Add(MemoKey, bSurf ? FVector2f(TerrainZ, CeilSurf)
                                                           : FVector2f(FLT_MAX, -FLT_MAX));
                 }