refactor(sheets, settings): drop the last sheet-ring remnants and dead settings

The far sheet ring was already gone from the runtime; this removes what was left of it: - UVoxelSettings::bFarSheetRing / FarSheetSpanLevels, the voxel.TestFarSheetRing switch, and their log/trace/dump fields. - The sheet branch of VoxelClipmapDesiredTiles (FParameters sheet fields, OuterShell sheet level, sheet ring emission). Output for the runtime configuration (sheet off) is unchanged: same rings, same alignment. - Tests: VerticalStrateReach now asserts the sheet-free selector (its expected counts were stale since the aligned-ring change 85a803b: LOD0 343 -> 512); ClipmapNoOverlap drops the sheet sweep cases and the frozen 7486c29 oracle's sheet branch. New expected values were computed with a Python port of the selector that reproduces the test's existing 635/594487 and 508/74295 measurements exactly; all 5,145 sweep cases pass (no overlap, full coverage). - Tools/VoxelForgeTest.ps1 no longer passes voxel.TestFarSheetRing or reports far_sheet_ring. The sheet_tile dump field is kept (the parity compare reads it). Also removes settings nothing reads: CeilingViewMultiplier, CeilingBandChunks (pre-clipmap ceiling band) and DensityVolumeMaxTasks (the volume fill runs on its own thread). Saved assets that still carry these values load normally; the values are ignored. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01URDGLsu7c4nunqNFPJEFPU
2026-09-28 14:53:25 +00:00
1 parent 3bd0fd36df
commit b6529719dd
@@ -122,22 +122,15 @@ namespace
        const int32 MaxLevel = FMath::Clamp(Parameters.MaxClipLevel, 0, 8);
        const int32 OuterRadius = VoxelClipmapDesiredTiles::OuterShellRadius(
            Parameters, Radius, MaxLevel);
-        int32 SheetLevel = MaxLevel;
-        int32 SheetRadius = OuterRadius;
-        VoxelClipmapDesiredTiles::OuterShell(
-            Parameters, Radius, MaxLevel, SheetLevel, SheetRadius);
-        const bool bSheetRing = SheetLevel > MaxLevel;
-        const int32 MaxMCRingLevel = bSheetRing ? SheetLevel - 1 : MaxLevel;

-        for (int32 Level = 0; Level <= MaxMCRingLevel; ++Level)
+        for (int32 Level = 0; Level <= MaxLevel; ++Level)
        {
            const int32 Pow = 1 << Level;
            const FIntVector CenterLevel = VoxelClipmapDesiredTiles::FloorDiv(Center, Pow);
            const FIntVector CenterFiner = Level > 0
                ? VoxelClipmapDesiredTiles::FloorDiv(Center, Pow >> 1)
                : FIntVector::ZeroValue;
-            const int32 LevelRadius = (Level == MaxLevel && !bSheetRing)
-                ? OuterRadius : Radius;
+            const int32 LevelRadius = (Level == MaxLevel) ? OuterRadius : Radius;

            int32 DeltaZMin = -LevelRadius;
            int32 DeltaZMax = LevelRadius;
@@ -178,50 +171,6 @@ namespace
                OutTiles.Emplace(Tile, Level);
            }
        }
-
-        if (bSheetRing)
-        {
-            const int32 SheetPow = 1 << SheetLevel;
-            const FIntVector CenterSheet = VoxelClipmapDesiredTiles::FloorDiv(Center, SheetPow);
-            const FIntVector CenterMC = VoxelClipmapDesiredTiles::FloorDiv(
-                Center, 1 << MaxMCRingLevel);
-            const int32 LevelDelta = SheetLevel - MaxMCRingLevel;
-
-            int32 DeltaZMin = -SheetRadius;
-            int32 DeltaZMax = SheetRadius;
-            if (MinChunkZ != MIN_int32)
-            {
-                DeltaZMin = FMath::Max(DeltaZMin,
-                    VoxelClipmapDesiredTiles::FloorDiv(MinChunkZ, SheetPow) - CenterSheet.Z);
-                DeltaZMax = FMath::Min(DeltaZMax,
-                    VoxelClipmapDesiredTiles::FloorDiv(MaxChunkZ, SheetPow) - CenterSheet.Z);
-            }
-
-            for (int32 DeltaZ = DeltaZMin; DeltaZ <= DeltaZMax; ++DeltaZ)
-            for (int32 DeltaY = -SheetRadius; DeltaY <= SheetRadius; ++DeltaY)
-            for (int32 DeltaX = -SheetRadius; DeltaX <= SheetRadius; ++DeltaX)
-            {
-                const FIntVector Tile = CenterSheet + FIntVector(DeltaX, DeltaY, DeltaZ);
-                const int32 TileMinZ = Tile.Z << SheetLevel;
-                const int32 TileMaxZ = ((Tile.Z + 1) << SheetLevel) - 1;
-                if (TileMaxZ < MinChunkZ || TileMinZ > MaxChunkZ)
-                {
-                    continue;
-                }
-
-                const bool bCovered =
-                    ((Tile.X << LevelDelta) >= CenterMC.X - Radius)
-                    && ((((Tile.X + 1) << LevelDelta) - 1) <= CenterMC.X + Radius)
-                    && ((Tile.Y << LevelDelta) >= CenterMC.Y - Radius)
-                    && ((((Tile.Y + 1) << LevelDelta) - 1) <= CenterMC.Y + Radius)
-                    && ((Tile.Z << LevelDelta) >= CenterMC.Z - Radius)
-                    && ((((Tile.Z + 1) << LevelDelta) - 1) <= CenterMC.Z + Radius);
-                if (!bCovered)
-                {
-                    OutTiles.Emplace(Tile, SheetLevel);
-                }
-            }
-        }
    }

    static FString DescribeMeasure(const FOverlapMeasure& Measure)
@@ -245,7 +194,6 @@ bool FVoxelForgeClipmapNoOverlapTest::RunTest(const FString& Parameters)
    Owner.ClipRadius = 3;
    Owner.MaxClipLevel = 5;
    Owner.RenderDistanceChunks = 768;
-    Owner.bFarSheetRing = false;

    FParameters Defaults;

@@ -291,16 +239,13 @@ bool FVoxelForgeClipmapNoOverlapTest::RunTest(const FString& Parameters)
        int32 Radius;
        int32 MaxLevel;
        int32 RenderDistance;
-        bool bSheet;
-        int32 SheetSpan;
    };
    static const FSweepSettings SweepSettings[] = {
-        {1, 0, 0, false, 2},
-        {2, 2, 0, false, 2},
-        {3, 4, 0, false, 2},
-        {2, 3, 49, false, 2},
-        {2, 3, 49, true, 2},
-        {2, 4, 87, true, 3},
+        {1, 0, 0},
+        {2, 2, 0},
+        {3, 4, 0},
+        {2, 3, 49},
+        {2, 4, 87},
    };

    int32 SweptCases = 0;
@@ -319,8 +264,6 @@ bool FVoxelForgeClipmapNoOverlapTest::RunTest(const FString& Parameters)
        P.ClipRadius = Sweep.Radius;
        P.MaxClipLevel = Sweep.MaxLevel;
        P.RenderDistanceChunks = Sweep.RenderDistance;
-        P.bFarSheetRing = Sweep.bSheet;
-        P.FarSheetSpanLevels = Sweep.SheetSpan;

        // Exercise the unbounded view, a tight local clamp, and a clamp crossing a tile boundary.
        for (int32 ClampCase = 0; ClampCase < 3; ++ClampCase)
@@ -353,9 +296,9 @@ bool FVoxelForgeClipmapNoOverlapTest::RunTest(const FString& Parameters)
                if (FirstFailure.IsEmpty())
                {
                    FirstFailure = FString::Printf(
-                        TEXT("overlap center=(%d,%d,%d) radius=%d level=%d distance=%d sheet=%d clamp=%d: %s"),
+                        TEXT("overlap center=(%d,%d,%d) radius=%d level=%d distance=%d clamp=%d: %s"),
                        X, Y, Z, Sweep.Radius, Sweep.MaxLevel, Sweep.RenderDistance,
-                        Sweep.bSheet ? 1 : 0, ClampCase, *DescribeMeasure(CurrentOverlap));
+                        ClampCase, *DescribeMeasure(CurrentOverlap));
                }
            }
            if (!CoversEveryLegacyTile(Legacy, Current, MinZ, MaxZ))
@@ -364,9 +307,9 @@ bool FVoxelForgeClipmapNoOverlapTest::RunTest(const FString& Parameters)
                if (FirstFailure.IsEmpty())
                {
                    FirstFailure = FString::Printf(
-                        TEXT("coverage center=(%d,%d,%d) radius=%d level=%d distance=%d sheet=%d clamp=%d"),
+                        TEXT("coverage center=(%d,%d,%d) radius=%d level=%d distance=%d clamp=%d"),
                        X, Y, Z, Sweep.Radius, Sweep.MaxLevel, Sweep.RenderDistance,
-                        Sweep.bSheet ? 1 : 0, ClampCase);
+                        ClampCase);
                }
            }
        }
@@ -29,15 +29,13 @@ bool FVoxelForgeVerticalStrateReachTest::RunTest(const FString& Parameters)
    Clipmap.ClipRadius = 3;
    Clipmap.MaxClipLevel = 3;
    Clipmap.RenderDistanceChunks = 768;
-    Clipmap.bFarSheetRing = true;
-    Clipmap.FarSheetSpanLevels = 2;

    TArray<FVoxelTileKey> Desired;
    VoxelClipmapDesiredTiles::Build(
        FIntVector(0, 0, PlayerChunkZ), MinChunkZ, MaxChunkZ, Clipmap, Desired);

    TArray<int32> CountsByLevel;
-    CountsByLevel.Init(0, 6);
+    CountsByLevel.Init(0, 4);
    for (const FVoxelTileKey& Tile : Desired)
    {
        if (CountsByLevel.IsValidIndex(Tile.Level))
@@ -46,7 +44,9 @@ bool FVoxelForgeVerticalStrateReachTest::RunTest(const FString& Parameters)
        }
    }

-    const int32 ExpectedCounts[] = {343, 218, 178, 178, 178, 9586};
+    // Aligned rings (child-pair boundaries) below MaxClipLevel; the MaxClipLevel ring is stretched
+    // to the 768-chunk render distance (radius 96 at level 3) and clamped to the strate's Z band.
+    const int32 ExpectedCounts[] = {512, 320, 272, 372442};
    for (int32 Level = 0; Level < static_cast<int32>(UE_ARRAY_COUNT(ExpectedCounts)); ++Level)
    {
        TestEqual(FString::Printf(TEXT("desired tile count at level %d"), Level),
@@ -63,26 +63,28 @@ bool FVoxelForgeVerticalStrateReachTest::RunTest(const FString& Parameters)

    TestTrue(TEXT("level 0 tile around the high pawn is present"),
             HasTile(0, FIntVector(0, 0, 0)));
-    TestTrue(TEXT("level 4 bridge tile covering the ground below the pawn is present"),
-             HasTile(4, FIntVector(0, 0, -3)));
-    TestTrue(TEXT("adjacent level 4 ground tile is present"),
-             HasTile(4, FIntVector(1, 0, -3)));
-    TestTrue(TEXT("outer level 5 sheet reaches the 768-chunk horizon"),
-             HasTile(5, FIntVector(24, 0, 0)));
+    TestTrue(TEXT("level 3 tile covering the ground below the pawn is present"),
+             HasTile(3, FIntVector(0, 0, -8)));
+    TestTrue(TEXT("adjacent level 3 ground tile is present"),
+             HasTile(3, FIntVector(1, 0, -8)));
+    TestTrue(TEXT("the outer level 3 ring reaches the 768-chunk horizon"),
+             HasTile(3, FIntVector(96, 0, 0)));
+    TestFalse(TEXT("the outer ring stops at the 768-chunk horizon"),
+              HasTile(3, FIntVector(97, 0, 0)));
    TestFalse(TEXT("clamping does not request a full hidden LOD0 column"),
              HasTile(0, FIntVector(0, 0, -47)));

-    for (int32 Level = 0; Level <= 5; ++Level)
+    for (int32 Level = 0; Level <= 3; ++Level)
    {
        TestTrue(FString::Printf(TEXT("clip level %d is non-empty"), Level),
                 CountsByLevel[Level] > 0);
    }

    AddInfo(FString::Printf(
-        TEXT("center_z=%d strate=[%d..%d] view=[%d..%d] levels=[%d,%d,%d,%d,%d,%d] total=%d"),
+        TEXT("center_z=%d strate=[%d..%d] view=[%d..%d] levels=[%d,%d,%d,%d] total=%d"),
        PlayerChunkZ, StrateBottomZ, StrateTopZ, MinChunkZ, MaxChunkZ,
        CountsByLevel[0], CountsByLevel[1], CountsByLevel[2], CountsByLevel[3],
-        CountsByLevel[4], CountsByLevel[5], Desired.Num()));
+        Desired.Num()));
    return true;
 }

@@ -9,10 +9,6 @@ namespace VoxelClipmapDesiredTiles
        int32 ClipRadius = 3;
        int32 MaxClipLevel = 4;
        int32 RenderDistanceChunks = 0;
-        // Far sheet ring selection. AVoxelWorld always passes false (the runtime does not mesh
-        // sheets); it stays here because the clipmap automation tests still exercise it.
-        bool bFarSheetRing = true;
-        int32 FarSheetSpanLevels = 2;
    };

    FORCEINLINE int32 FloorDiv(int32 Value, int32 Divisor)
@@ -62,12 +58,6 @@ namespace VoxelClipmapDesiredTiles
    {
        OutLevel = MaxLevel;
        OutRadius = OuterShellRadius(Parameters, Radius, MaxLevel);
-        if (Parameters.bFarSheetRing && OutRadius > Radius)
-        {
-            OutLevel = MaxLevel + FMath::Clamp(Parameters.FarSheetSpanLevels, 1, 4);
-            OutRadius = FMath::Max(1,
-                (Parameters.RenderDistanceChunks + (1 << OutLevel) - 1) >> OutLevel);
-        }
    }

    FORCEINLINE void ResolveVerticalBounds(
@@ -99,37 +89,21 @@ namespace VoxelClipmapDesiredTiles
        const int32 Radius = FMath::Max(1, Parameters.ClipRadius);
        const int32 MaxLevel = FMath::Clamp(Parameters.MaxClipLevel, 0, 8);
        const int32 OuterRadius = OuterShellRadius(Parameters, Radius, MaxLevel);
-        int32 SheetLevel = MaxLevel;
-        int32 SheetRadius = OuterRadius;
-        OuterShell(Parameters, Radius, MaxLevel, SheetLevel, SheetRadius);
-        const bool bSheetRing = SheetLevel > MaxLevel;
-        const int32 MaxMCRingLevel = bSheetRing ? SheetLevel - 1 : MaxLevel;
        FIntVector PreviousRingMin = FIntVector::ZeroValue;
        FIntVector PreviousRingMax = FIntVector::ZeroValue;
-        FIntVector MCRingMin = FIntVector::ZeroValue;
-        FIntVector MCRingMax = FIntVector::ZeroValue;

-        for (int32 Level = 0; Level <= MaxMCRingLevel; ++Level)
+        for (int32 Level = 0; Level <= MaxLevel; ++Level)
        {
            const int32 Pow = 1 << Level;
            const FIntVector CenterLevel = FloorDiv(Center, Pow);
-            const int32 LevelRadius = (Level == MaxLevel && !bSheetRing)
-                ? OuterRadius : Radius;
+            const int32 LevelRadius = (Level == MaxLevel) ? OuterRadius : Radius;

            // Every finer shell must end on a complete child-pair boundary so a coarser tile is
-            // either wholly inside it or wholly outside it. The final MC ring uses the sheet's
-            // grouping width when a sheet ring follows it; otherwise the ordinary LOD boundary
-            // only needs pair alignment.
-            const int32 RingAlignment = Level < MaxMCRingLevel
-                ? 2
-                : (bSheetRing ? (1 << (SheetLevel - MaxMCRingLevel)) : 1);
+            // either wholly inside it or wholly outside it. The outermost ring has no coarser
+            // neighbour and needs no alignment.
+            const int32 RingAlignment = Level < MaxLevel ? 2 : 1;
            FIntVector RingMin, RingMax;
            AlignedRingBounds(CenterLevel, LevelRadius, RingAlignment, RingMin, RingMax);
-            if (Level == MaxMCRingLevel)
-            {
-                MCRingMin = RingMin;
-                MCRingMax = RingMax;
-            }

            int32 DeltaZMin = RingMin.Z - CenterLevel.Z;
            int32 DeltaZMax = RingMax.Z - CenterLevel.Z;
@@ -174,48 +148,5 @@ namespace VoxelClipmapDesiredTiles
            PreviousRingMin = RingMin;
            PreviousRingMax = RingMax;
        }
-
-        if (bSheetRing)
-        {
-            const int32 SheetPow = 1 << SheetLevel;
-            const FIntVector CenterSheet = FloorDiv(Center, SheetPow);
-            const int32 LevelDelta = SheetLevel - MaxMCRingLevel;
-            const int32 MCPerSheet = 1 << LevelDelta;
-
-            int32 DeltaZMin = -SheetRadius;
-            int32 DeltaZMax = SheetRadius;
-            if (MinChunkZ != MIN_int32)
-            {
-                DeltaZMin = FMath::Max(DeltaZMin,
-                    FloorDiv(MinChunkZ, SheetPow) - CenterSheet.Z);
-                DeltaZMax = FMath::Min(DeltaZMax,
-                    FloorDiv(MaxChunkZ, SheetPow) - CenterSheet.Z);
-            }
-
-            for (int32 DeltaZ = DeltaZMin; DeltaZ <= DeltaZMax; ++DeltaZ)
-            for (int32 DeltaY = -SheetRadius; DeltaY <= SheetRadius; ++DeltaY)
-            for (int32 DeltaX = -SheetRadius; DeltaX <= SheetRadius; ++DeltaX)
-            {
-                const FIntVector Tile = CenterSheet + FIntVector(DeltaX, DeltaY, DeltaZ);
-                const int32 TileMinZ = Tile.Z << SheetLevel;
-                const int32 TileMaxZ = ((Tile.Z + 1) << SheetLevel) - 1;
-                if (TileMaxZ < MinChunkZ || TileMinZ > MaxChunkZ)
-                {
-                    continue;
-                }
-
-                const bool bCovered =
-                    (Tile.X * MCPerSheet >= MCRingMin.X)
-                    && ((Tile.X + 1) * MCPerSheet - 1 <= MCRingMax.X)
-                    && (Tile.Y * MCPerSheet >= MCRingMin.Y)
-                    && ((Tile.Y + 1) * MCPerSheet - 1 <= MCRingMax.Y)
-                    && (Tile.Z * MCPerSheet >= MCRingMin.Z)
-                    && ((Tile.Z + 1) * MCPerSheet - 1 <= MCRingMax.Z);
-                if (!bCovered)
-                {
-                    OutTiles.Emplace(Tile, SheetLevel);
-                }
-            }
-        }
    }
 }
@@ -1584,16 +1584,12 @@ void AVoxelWorld::BeginPlay()
    int32 TestMaxClipLevel = -1;
    const bool bTestMaxClipLevel =
        FParse::Value(FCommandLine::Get(), TEXT("voxel.TestMaxClipLevel="), TestMaxClipLevel);
-    int32 TestFarSheetRing = -1;
-    const bool bTestFarSheetRing =
-        FParse::Value(FCommandLine::Get(), TEXT("voxel.TestFarSheetRing="), TestFarSheetRing);
-    if (bTestRenderDistance || bTestMaxClipLevel || bTestFarSheetRing)
+    if (bTestRenderDistance || bTestMaxClipLevel)
    {
        if (UVoxelSettings* TestSettings = DuplicateObject<UVoxelSettings>(Settings, this))
        {
            const int32 AuthoredRenderDistance = Settings->RenderDistanceChunks;
            const int32 AuthoredMaxClipLevel = Settings->MaxClipLevel;
-            const bool bAuthoredFarSheetRing = Settings->bFarSheetRing;
            if (bTestRenderDistance)
            {
                TestSettings->RenderDistanceChunks = TestRenderDistanceChunks;
@@ -1602,18 +1598,12 @@ void AVoxelWorld::BeginPlay()
            {
                TestSettings->MaxClipLevel = FMath::Clamp(TestMaxClipLevel, 0, 8);
            }
-            if (bTestFarSheetRing)
-            {
-                TestSettings->bFarSheetRing = TestFarSheetRing != 0;
-            }
            Settings = TestSettings;
            UE_LOG(LogTemp, Display,
                TEXT("[VoxelForgeHorizonMeasure] transient_settings=1 "
-                     "render_distance_chunks=%d authored=%d max_clip_level=%d authored=%d "
-                     "far_sheet_ring=%d authored=%d"),
+                     "render_distance_chunks=%d authored=%d max_clip_level=%d authored=%d"),
                Settings->RenderDistanceChunks, AuthoredRenderDistance,
-                Settings->MaxClipLevel, AuthoredMaxClipLevel,
-                Settings->bFarSheetRing ? 1 : 0, bAuthoredFarSheetRing ? 1 : 0);
+                Settings->MaxClipLevel, AuthoredMaxClipLevel);
        }
    }

@@ -1705,18 +1695,17 @@ void AVoxelWorld::BeginPlay()
            TEXT("\"asset\":\"%s\",\"seed\":%d,\"total_strates\":%d,\"inter_strate_gap_chunks\":%d,"
                 "\"strate_pool\":%d,\"strate_content_cut_min_level\":%d,"
                 "\"effective_strate_content_cut_min_level\":%d,\"max_clip_level\":%d,\"clip_radius\":%d,"
-                 "\"render_distance_chunks\":%d,\"far_sheet_ring\":%d,\"far_sheet_span_levels\":%d,"
+                 "\"render_distance_chunks\":%d,"
                 "\"enable_density_volume\":%d,\"density_volume_resolution\":%d,\"density_volume_levels\":%d,"
-                 "\"density_volume_max_tasks\":%d,\"density_volume_gpu_upload\":%d"),
+                 "\"density_volume_gpu_upload\":%d"),
            *SettingsPath,
            Settings->GetEffectiveWorldSeed(), Settings->TotalStrates,
            Settings->InterStrateGapChunks, Settings->StratePool.Num(),
            Settings->StrateContentCutMinLevel,
            Settings->GetEffectiveStrateContentCutMinLevel(), Settings->MaxClipLevel,
            Settings->ClipRadius, Settings->RenderDistanceChunks,
-            Settings->bFarSheetRing ? 1 : 0, Settings->FarSheetSpanLevels,
            Settings->bEnableDensityVolume ? 1 : 0, Settings->DensityVolumeResolution,
-            Settings->DensityVolumeLevels, Settings->DensityVolumeMaxTasks,
+            Settings->DensityVolumeLevels,
            Settings->bDensityVolumeGPUUpload ? 1 : 0));
    }

@@ -2291,7 +2280,6 @@ void AVoxelWorld::WriteTileHashDump()
        Writer->WriteValue(TEXT("coarse_tile_cells"), Settings->CoarseTileCells);
        Writer->WriteValue(TEXT("max_clip_level"), Settings->MaxClipLevel);
        Writer->WriteValue(TEXT("render_distance_chunks"), Settings->RenderDistanceChunks);
-        Writer->WriteValue(TEXT("far_sheet_ring"), Settings->bFarSheetRing);
        Writer->WriteValue(TEXT("strate_content_cut_min_level"),
            Settings->GetEffectiveStrateContentCutMinLevel());
        Writer->WriteObjectEnd();
@@ -3016,11 +3004,10 @@ void AVoxelWorld::AdvanceHeadlessCollisionGateStressTest(
    {
        UE_LOG(LogTemp, Display,
            TEXT("[VoxelForgeCollisionGateStressTest] owner_settings clip_radius=%d "
-                 "max_clip_level=%d render_distance_chunks=%d far_sheet_ring=%d"),
+                 "max_clip_level=%d render_distance_chunks=%d"),
            Settings != nullptr ? Settings->ClipRadius : -1,
            Settings != nullptr ? Settings->MaxClipLevel : -1,
-            Settings != nullptr ? Settings->RenderDistanceChunks : -1,
-            Settings != nullptr && Settings->bFarSheetRing ? 1 : 0);
+            Settings != nullptr ? Settings->RenderDistanceChunks : -1);
        float CapsuleHalfHeightCm = 0.0f;
        if (const ACharacter* Character = Cast<ACharacter>(PlayerPawn))
        {
@@ -6468,14 +6455,12 @@ static FORCEINLINE FIntVector VF_FloorDiv(const FIntVector& V, int32 D)
 }

 // The outer shell is the MaxClipLevel ring stretched to RenderDistanceChunks. Shared by desired
-// selection and range culling so both use the same outer horizon. The selector's far sheet ring
-// is not part of the runtime, so it is always switched off here.
+// selection and range culling so both use the same outer horizon.
 static FORCEINLINE void VF_OuterShell(const UVoxelSettings* Settings, int32 R, int32 MaxLevel,
                                      int32& OutLevel, int32& OutRadius)
 {
    VoxelClipmapDesiredTiles::FParameters Parameters;
    Parameters.RenderDistanceChunks = Settings ? Settings->RenderDistanceChunks : 0;
-    Parameters.bFarSheetRing = false;
    VoxelClipmapDesiredTiles::OuterShell(Parameters, R, MaxLevel, OutLevel, OutRadius);
 }

@@ -6520,7 +6505,6 @@ void AVoxelWorld::BuildDesiredTiles(const FIntVector& Center, const FVector& Pla
    TileParameters.ClipRadius = R;
    TileParameters.MaxClipLevel = MaxLevel;
    TileParameters.RenderDistanceChunks = Settings ? Settings->RenderDistanceChunks : 0;
-    TileParameters.bFarSheetRing = false;
    VoxelClipmapDesiredTiles::Build(Center, ZLo, ZHi, TileParameters, DesiredSorted);
    for (const FVoxelTileKey& Key : DesiredSorted)
    {
@@ -123,21 +123,6 @@ public:
 		return FMath::Clamp(FMath::Max(StrateContentCutMinLevel, 1), 1, 9);
 	}

-	// Open-world SKY reach: the sky-cap ceiling of an open strate (SurfaceWorld / FloatingIslands)
-	// is FAR, so the ceiling BAND is streamed across a wider horizontal radius = ViewDistanceXY ×
-	// this, so the sky reaches toward the horizon instead of being a patch over the player's head.
-	// Only the ceiling band (top CeilingBandChunks of the strate) gets the wide radius — the empty
-	// air below it stays at base XY. Cost grows ~ multiplier² (more far chunks/draws; gen is cheap
-	// and batching keeps the game-thread cost low). 1 = off. Live-tunable on the asset — push to 4
-	// if the draw budget allows; a proper to-the-horizon view (terrain too) is the chunk-LOD clipmap.
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Streaming", meta = (ClampMin = "1"))
-	int32 CeilingViewMultiplier = 2;
-
-	// How many chunks down from the strate top get the wide CeilingViewMultiplier radius (covers
-	// the sky-cap slab). Bigger = no gaps if the ceiling surface dips, but more far chunks.
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Streaming", meta = (ClampMin = "1"))
-	int32 CeilingBandChunks = 4;
-
 	//=========================================================================
 	// CLIPMAP (chunked-LOD streaming — supersedes the ViewDistance box above)
 	//=========================================================================
@@ -183,16 +168,6 @@ public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Clipmap", meta = (ClampMin = "0"))
 	int32 RenderDistanceChunks = 768;

-	// UNUSED: the far sheet ring was removed from the runtime; the render-distance ring is always
-	// marching-cubes tiles at MaxClipLevel. Kept only so saved assets and the test harness's
-	// `voxel.TestFarSheetRing` switch still load; it has no effect.
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Clipmap")
-	bool bFarSheetRing = false;
-
-	// UNUSED (see bFarSheetRing). Kept so saved assets still load; it has no effect.
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Clipmap", meta = (ClampMin = "1", ClampMax = "4", EditCondition = "bFarSheetRing"))
-	int32 FarSheetSpanLevels = 2;
-
 	// SKIRTS — seal the thin cracks where neighbouring clipmap shells (different resolutions) meet.
 	// A short wall is extruded into the solid from each surface edge on the tile's outer faces.
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Clipmap")
@@ -336,12 +311,6 @@ public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Lighting", meta = (ClampMin = "1", ClampMax = "5"))
 	int32 DensityVolumeLevels = 3;

-	// DEPRECATED / unused: the volume fill no longer runs on the shared UE::Tasks pool (where it
-	// starved behind mesh-gen). It now runs on ONE dedicated thread off the pool, so there's no task
-	// budget to cap. Kept only so existing saved assets don't error; safe to ignore.
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Lighting", meta = (ClampMin = "1", ClampMax = "16"))
-	int32 DensityVolumeMaxTasks = 4;
-
 	// A fill box is split into Z-slabs of at most this many cells per task, so no single task is
 	// huge (a full level refill on startup/teleport fans out across workers). Lower = more, smaller
 	// tasks (better parallelism / latency); higher = fewer, fatter tasks.
@@ -54,7 +54,6 @@ $HorizonMetrics = [ordered]@{
    status = 'not_run'
    level = $HorizonLevel
    render_distance_chunks = $HorizonRenderDistanceChunks
-    far_sheet_ring = $false
 }
 $HorizonRenderMetrics = [ordered]@{ requested = $Scenario -eq 'horizon-render'; status = 'not_run' }
 $DeterminismEvidence = [ordered]@{ requested = $Scenario -eq 'determinism'; status = 'not_run' }
@@ -1293,7 +1292,6 @@ try {
            $tracePath = Join-Path $RunRoot 'horizon_trace.jsonl'
            $baseCvars['voxel.TestRenderDistanceChunks'] = $HorizonRenderDistanceChunks
            $baseCvars['voxel.TestMaxClipLevel'] = $HorizonLevel
-            $baseCvars['voxel.TestFarSheetRing'] = 0
            $baseCvars['voxel.StartupTraceFile'] = $tracePath
            $baseCvars['voxel.StartupTraceMaxTiles'] = 16384
            $baseCvars['voxel.TestExitOnSteady'] = 1
@@ -1311,7 +1309,6 @@ try {
            $tracePath = Join-Path $RunRoot 'horizon_render_trace.jsonl'
            $baseCvars['voxel.TestRenderDistanceChunks'] = $HorizonRenderDistanceChunks
            $baseCvars['voxel.TestMaxClipLevel'] = $HorizonLevel
-            $baseCvars['voxel.TestFarSheetRing'] = 0
            $baseCvars['voxel.StartupTraceFile'] = $tracePath
            $baseCvars['voxel.StartupTraceMaxTiles'] = 16384
            $baseCvars['voxel.TestCeilingView'] = 1
@@ -1340,7 +1337,6 @@ try {
            $determinismBase = [ordered]@{
                'voxel.TestRenderDistanceChunks' = $HorizonRenderDistanceChunks
                'voxel.TestMaxClipLevel' = $HorizonLevel
-                'voxel.TestFarSheetRing' = 0
                'voxel.TestExitOnSteady' = 1
                'voxel.StartupTraceMaxTiles' = 16384
                'voxel.OuterClassifierMode' = 0
@@ -1369,7 +1365,6 @@ try {
            $DeterminismEvidence = Compare-DeterminismDumps $defaultDump $crtFma3OffDump
            $DeterminismEvidence.level = $HorizonLevel
            $DeterminismEvidence.render_distance_chunks = $HorizonRenderDistanceChunks
-            $DeterminismEvidence.far_sheet_ring = $false
            $DeterminismEvidence.default_measurement = $defaultMetrics
            $DeterminismEvidence.crt_fma3_off_measurement = $crtFma3OffMetrics
            $GameMetrics = $crtFma3OffMetrics