perf(core): FI LOD0 attribution, exact Z-inner traversal; fix a mesh gap at the passage shaft foot (L57); R26

Sampled cycle attribution of FI LOD0 field work: grid fill 83%, boundary 13%, skirts 4%; island roots,
columns and helix dominate, the column cache path is real but secondary (no thrashing). FI-only Z-inner
traversal at LOD0 (same lattice samples, exact) cuts FI whole view 5.35 -> 5.03 s and moving p50 by 12%;
global Z-inner and <=4-island culling were measured and rejected. The meshing band now includes the planned
passage support column's conservative bounds, closing a real gap where the arrival shaft meets the floor
(WorldAssemblyEvaluatorVersion 208 -> 209). fast/medium/full PASS, Clang and GCC.
Research R26 (self-checked): native lattice (maze/shaft) generator design.

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

Standalone/Core/src/CoreNamespacePreamble.h

@@ -56,6 +56,7 @@
 #include "VoxelForgeCore/VoxelForgeCore.h"
 #include "VoxelForgeCore/ThreadLocalStorage.h"
 #include "VoxelForgeCore/SharedColumnCache.h"
+#include "VoxelForgeCore/FloatingIslandInstrumentation.h"
 
 // Keep Core's expression-level FMA behavior fixed regardless of the toolchain setting.
 // Clang's "fast" mode ignores the pragma, so Core's runtime self-test rejects that build.

Standalone/Core/src/FloatingIslandsInternal.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include "VoxelForgeCore/ThreadLocalStorage.h"
+#include "VoxelForgeCore/CpuCycleCounter.h"
+#include "VoxelForgeCore/FloatingIslandInstrumentation.h"
+#include "VoxelForgeCore/SharedColumnCache.h"
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
@@ -474,7 +477,10 @@ namespace floating_island_detail
     struct FIslandColumnCacheInstrumentation
     {
         std::uint64_t localHits=0,localMisses=0,localConflictReplacements=0;
+        std::uint64_t localProbeCycles=0,localProbeSamples=0;
+        std::uint64_t tileStartCycles=0,tileCycles=0;
         VoxelForgeCoreShared::FColumnCacheMetrics shared;
+        FIslandFieldAttributionInstrumentation attribution;
     };
 
     inline FIslandColumnCacheInstrumentation*& ActiveIslandColumnCacheInstrumentation() noexcept
@@ -488,16 +494,49 @@ namespace floating_island_detail
     {
         FIslandColumnCacheInstrumentation* previous=ActiveIslandColumnCacheInstrumentation();
         ActiveIslandColumnCacheInstrumentation()=value;
+        SetActiveIslandFieldAttribution(value?&value->attribution:nullptr);
         return previous;
     }
 
     using FSharedIslandColumnCache =
         VoxelForgeCoreShared::TSharedColumnValueCache<FIslandColumnCacheEntry,16384,4>;
 
+    struct FIslandColumnTraceKey
+    {
+        bool valid=false;
+        std::uint64_t recipeHash=0,planHash=0,island=0;
+        std::int64_t x=0,y=0;
+    };
+
+    struct FIslandColumnReuseTrace
+    {
+        std::array<FIslandColumnTraceKey,128> recentMisses{};
+        std::array<FIslandColumnTraceKey,128> recentEvictions{};
+        std::uint64_t missSequence=0,printedEvents=0;
+    };
+
+    inline bool SameTraceKey(const FIslandColumnTraceKey& left,
+                             const FIslandColumnTraceKey& right) noexcept
+    {
+        return left.valid&&right.valid&&left.recipeHash==right.recipeHash
+            &&left.planHash==right.planHash&&left.island==right.island
+            &&left.x==right.x&&left.y==right.y;
+    }
+
+    inline std::size_t TraceKeyIndex(const FIslandColumnTraceKey& key) noexcept
+    {
+        std::uint64_t hash=key.island^static_cast<std::uint64_t>(key.x)*0x9e3779b97f4a7c15ull
+            ^static_cast<std::uint64_t>(key.y)*0xc2b2ae3d27d4eb4full
+            ^key.recipeHash^std::rotl(key.planHash,17);
+        hash^=hash>>33;hash*=0xff51afd7ed558ccdull;hash^=hash>>33;
+        return static_cast<std::size_t>(hash&127u);
+    }
+
     inline const FIslandColumnCacheEntry& IslandColumnCache(
         const FloatingIslandRecipeV1& recipe,const FloatingIslandPlanV1& plan,
         const FloatingIslandAnchorV1& island,double x,double y)
     {
+        FScopedIslandAttributionTimer columnTimer(EIslandAttributionBucket::Column);
         // Density samples arrive on integer Core lattice columns; reuse the exact column metrics
         // across Z samples without changing the field value or touching shared world state.
         // Les echantillons suivent les colonnes Core entieres; reutiliser les memes metriques XY.
@@ -507,6 +546,7 @@ namespace floating_island_detail
         static thread_local VoxelForgeCoreThreadLocal::FLazy<
             std::array<FIslandColumnCacheEntry,SetCount*Ways>> Cache;
         auto& cache=Cache.Get();
+        FScopedIslandAttributionTimer localProbeTimer(EIslandAttributionBucket::LocalProbe);
         const std::int64_t SampleX=static_cast<std::int64_t>(x);
         const std::int64_t SampleY=static_cast<std::int64_t>(y);
         std::uint64_t IndexKey=island.stableId
@@ -545,10 +585,56 @@ namespace floating_island_detail
             if(!Entry.bValid&&!bFoundInvalid)
             {Replacement=&Entry;bFoundInvalid=true;}
         }
+        localProbeTimer.Stop();
         if(auto* stats=ActiveIslandColumnCacheInstrumentation())
         {
             ++stats->localMisses;
             if(!bFoundInvalid)++stats->localConflictReplacements;
+            static thread_local FIslandColumnReuseTrace trace;
+            if((++trace.missSequence&1023u)==0)
+            {
+                auto& a=stats->attribution;
+                ++a.traceSampledMisses;
+                const FIslandColumnTraceKey requested{true,recipe.contentHash,
+                    plan.contentHash,island.stableId,SampleX,SampleY};
+                const std::size_t requestSlot=TraceKeyIndex(requested);
+                const bool seenBefore=SameTraceKey(trace.recentMisses[requestSlot],requested);
+                const bool reusedEviction=SameTraceKey(
+                    trace.recentEvictions[requestSlot],requested);
+                if(seenBefore)++a.traceSeenBefore;
+                if(reusedEviction)
+                {
+                    ++a.traceReusedEvictions;
+                    trace.recentEvictions[requestSlot].valid=false;
+                }
+                FIslandColumnTraceKey evicted{};
+                std::size_t replacementWay=0;
+                if(!bFoundInvalid&&Replacement)
+                {
+                    evicted={Replacement->bValid,Replacement->RecipeContentHash,
+                        Replacement->PlanContentHash,Replacement->StableId,
+                        Replacement->SampleX,Replacement->SampleY};
+                    replacementWay=static_cast<std::size_t>(Replacement-&cache[Base]);
+                    ++a.traceEvictions;
+                    if(evicted.valid)
+                        trace.recentEvictions[TraceKeyIndex(evicted)]=evicted;
+                }
+                trace.recentMisses[requestSlot]=requested;
+                if(trace.printedEvents<16&&a.traceCount<a.traceSet.size())
+                {
+                    const std::size_t event=a.traceCount++;
+                    ++trace.printedEvents;
+                    a.traceSet[event]=Base/Ways;
+                    a.traceX[event]=SampleX;a.traceY[event]=SampleY;
+                    a.traceIsland[event]=island.stableId;
+                    a.traceEvictedX[event]=evicted.valid?evicted.x:0;
+                    a.traceEvictedY[event]=evicted.valid?evicted.y:0;
+                    a.traceEvictedIsland[event]=evicted.valid?evicted.island:0;
+                    a.traceFlags[event]=static_cast<std::uint8_t>(
+                        (!bFoundInvalid?1u:0u)|(seenBefore?2u:0u)|(reusedEviction?4u:0u)
+                        |(replacementWay<<3));
+                }
+            }
         }
 
         const auto build=[&]()
@@ -575,9 +661,14 @@ namespace floating_island_detail
             Entry.Radial=std::hypot(Entry.DeltaX,Entry.DeltaY);
             Entry.Angle=std::atan2(Entry.DeltaY,Entry.DeltaX);
             Entry.LobePhase=LobePhase(recipe,island);
+            double contourOffset=0.0;
+            {
+                FScopedIslandAttributionTimer helixTimer(EIslandAttributionBucket::Helix);
+                contourOffset=LobeOffsetWithPhase(recipe,Entry.Angle,
+                    static_cast<double>(island.topZSubvoxels),Entry.LobePhase);
+            }
             const double EffectiveRadius=std::max(1.0,static_cast<double>(island.radiusSubvoxels)
-                +LobeOffsetWithPhase(recipe,Entry.Angle,static_cast<double>(island.topZSubvoxels),
-                    Entry.LobePhase));
+                +contourOffset);
             const double Edge=std::clamp(Entry.Radial/EffectiveRadius,0.0,1.0);
             const double Drop=(1.0-Q16ToDouble(recipe.topFlattenQ16))
                 *static_cast<double>(island.topHalfSubvoxels)*2.0*Edge*Edge;
@@ -594,8 +685,11 @@ namespace floating_island_detail
                 plan.contentHash,SampleX,SampleY,island.stableId};
             bool computed=false;
             auto* stats=ActiveIslandColumnCacheInstrumentation();
-            Entry=shared->getOrCompute(key,build,computed,
-                stats?&stats->shared:nullptr);
+            {
+                FScopedIslandAttributionTimer sharedCacheTimer(EIslandAttributionBucket::SharedCache);
+                Entry=shared->getOrCompute(key,build,computed,
+                    stats?&stats->shared:nullptr);
+            }
         }
         else Entry=build();
         *Replacement=Entry;
@@ -658,6 +752,7 @@ namespace floating_island_detail
                                   const FloatingIslandAnchorV1& island,
                                   std::int32_t rootIndex, double x, double y, double z)
     {
+        FScopedIslandAttributionTimer attributionTimer(EIslandAttributionBucket::Root);
         // Cache derived root constants per worker. The complete immutable input key keeps this
         // value-only cache safe across worlds, epochs and worker schedules.
         // Mettre en cache les constantes par worker; la cle complete evite tout partage d'etat.
@@ -778,6 +873,7 @@ namespace floating_island_detail
                                 const FloatingIslandAnchorV1& island,
                                 double x, double y, double z)
     {
+        FScopedIslandAttributionTimer islandTimer(EIslandAttributionBucket::Island);
         if (recipe.geometryVersion < 2)
         {
             const double dx = x - static_cast<double>(island.centerSubvoxels[0]);
@@ -805,8 +901,13 @@ namespace floating_island_detail
         const double radial=Column.Radial;
         const double topZ = static_cast<double>(island.topZSubvoxels);
         const double radius = static_cast<double>(island.radiusSubvoxels);
+        double contourOffset=0.0;
+        {
+            FScopedIslandAttributionTimer helixTimer(EIslandAttributionBucket::Helix);
+            contourOffset=LobeOffsetWithPhase(recipe,Column.Angle,z,Column.LobePhase);
+        }
         const double effectiveRadius = std::max(0.0,
-            radius + LobeOffsetWithPhase(recipe,Column.Angle,z,Column.LobePhase));
+            radius + contourOffset);
         const double edge = std::clamp(radial / std::max(effectiveRadius, 1.0), 0.0, 1.0);
         const double lowerSurface = static_cast<double>(IslandCrustBottom(recipe, island))
             + radius * 0.16 * edge * edge;
@@ -853,6 +954,7 @@ namespace floating_island_detail
                                    bool* topSurface = nullptr,
                                    double* alongFraction = nullptr)
     {
+        FScopedIslandAttributionTimer connectorTimer(EIslandAttributionBucket::Connector);
         const double ax = static_cast<double>(edge.startSubvoxels[0]);
         const double ay = static_cast<double>(edge.startSubvoxels[1]);
         const double az = static_cast<double>(edge.startSubvoxels[2]);
@@ -2184,14 +2286,19 @@ bool FloatingIslandFieldV1::isValid() const noexcept
 std::int64_t FloatingIslandFieldV1::densitySubvoxels(std::int64_t x,
     std::int64_t y, std::int64_t z) const noexcept
 {
+    floating_island_detail::FScopedIslandAttributionTimer fieldTimer(
+        floating_island_detail::EIslandAttributionBucket::Field);
     // The selected evaluator validates once; do not scan the plan twice per scoped sample.
     // L'evaluateur choisi valide une seule fois; ne pas reparcourir le plan a chaque echantillon.
+    std::int64_t density=floating_island_detail::MaxDensity;
     if (const auto* list = ScopedWorldAssemblyFeatureQueriesV1::find(recipe_, plan_, x, y, z))
-        return densitySubvoxelsForTile(x, y, z, *list);
-    if (!isValid() || !floating_island_detail::ValidScalar(x)
+        density=densitySubvoxelsForTile(x, y, z, *list);
+    else if (!isValid() || !floating_island_detail::ValidScalar(x)
         || !floating_island_detail::ValidScalar(y) || !floating_island_detail::ValidScalar(z))
-        return floating_island_detail::MaxDensity;
-    return floating_island_detail::FieldDensity(*recipe_, *plan_, x, y, z);
+        density=floating_island_detail::MaxDensity;
+    else density=floating_island_detail::FieldDensity(*recipe_, *plan_, x, y, z);
+    fieldTimer.Stop();
+    return density;
 }
 
 std::vector<WorldAssemblyFeatureBoundsV1> FloatingIslandFieldV1::solidSupportBounds() const

Standalone/Core/src/ShapeWorldInternal.h

@@ -8,6 +8,7 @@
 #include "VoxelDensityPrimitives.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 #include "VoxelForgeFieldShared.h"
+#include "VoxelForgeCore/FloatingIslandInstrumentation.h"
 
 #include <algorithm>
 #include <array>
@@ -414,6 +415,12 @@ public:
         return FindBoundStratumForChunk(FMath::FloorToInt(Z/LayoutWidth));
     }
 
+    bool IsFloatingIslandFieldAtZ(float Z) const
+    {
+        const FBoundStratumField* Bound=FindBoundStratumForZ(Z);
+        return Bound&&Bound->Kind==FBoundStratumField::EKind::FloatingIslands;
+    }
+
     const FBoundStratumField* FindBoundStratumForManagerZ(float Z) const
     {
         if(!std::isfinite(Z)||!Owner||!(BoundManagerLayoutChunkWidthVoxels>0.0f))
@@ -6139,6 +6146,7 @@ private:
         const auto* FieldAdapter=std::get_if<FFloatingIslandFieldAdapter>(
             &Bound->Evaluator);
         if(!FieldAdapter||!FieldAdapter->Evaluator.isValid())return false;
+        VoxelForgeCore::floating_island_detail::FScopedIslandAttributionSample attributionSample;
         constexpr double Scale=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
         constexpr double Maximum=1000000000000.0/Scale;
         if(std::abs(static_cast<double>(X))>Maximum||std::abs(static_cast<double>(Y))>Maximum
@@ -6266,8 +6274,12 @@ private:
         }
         if(mouthFilterWeight>0.0)
         {
+            VoxelForgeCore::floating_island_detail::FScopedIslandAttributionTimer mouthFilterTimer(
+                VoxelForgeCore::floating_island_detail::EIslandAttributionBucket::MouthFilter);
             constexpr std::int64_t FilterStep=8*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
             std::int64_t weightedSum=0;
+            VoxelForgeCore::floating_island_detail::FScopedIslandFieldCaller passageFilterCaller(
+                VoxelForgeCore::floating_island_detail::EIslandFieldCaller::PassageFilter);
             for(int dz=-1;dz<=1;++dz)
                 for(int dy=-1;dy<=1;++dy)
                     for(int dx=-1;dx<=1;++dx)
@@ -6306,6 +6318,8 @@ private:
             {
                 bool surroundedByAir=true;
                 std::int64_t minimumAirDensity=std::numeric_limits<std::int64_t>::max();
+                VoxelForgeCore::floating_island_detail::FScopedIslandFieldCaller passageFilterCaller(
+                    VoxelForgeCore::floating_island_detail::EIslandFieldCaller::PassageFilter);
                 for(std::size_t axis=0;axis<3&&surroundedByAir;++axis)
                     for(const int sign:{-1,1})
                     {
@@ -6323,6 +6337,8 @@ private:
                 if(surroundedByAir)Density=std::max(Density,minimumAirDensity);
             }
         }
+        VoxelForgeCore::floating_island_detail::FScopedIslandAttributionTimer boundaryTimer(
+            VoxelForgeCore::floating_island_detail::EIslandAttributionBucket::Boundary);
         const std::int64_t Bottom=Plan->manifest.recipe.layoutMinimumZSubvoxels;
         const std::int64_t Top=Plan->manifest.recipe.layoutMaximumZSubvoxels;
         const std::int64_t Seal=Plan->manifest.recipe.boundarySealSubvoxels;

Standalone/Core/src/VoxelForgeCore.cpp

@@ -17,6 +17,7 @@
 #include <thread>
 #include <new>
 #include <stdexcept>
+#include <sstream>
 
 namespace vfcore::detail
 {
@@ -2013,6 +2014,7 @@ namespace VoxelForgeCore
                 ?impl_->sharedHeightfieldColumns.get():nullptr,
             options.useSharedColumnCache?impl_->sharedIslandColumns.get():nullptr);
         floating_island_detail::FIslandColumnCacheInstrumentation islandCacheInstrumentation;
+        islandCacheInstrumentation.tileStartCycles=VoxelForgeCoreShared::ReadCpuCycles();
         FScopedIslandColumnCacheInstrumentation islandCacheScope(
             &islandCacheInstrumentation,options.instrumentTileDrain);
         const auto& world=*impl_->owner;
@@ -2161,6 +2163,8 @@ namespace VoxelForgeCore
         const auto CopyIslandCacheMetrics=[&]()
         {
             if(!options.instrumentTileDrain)return;
+            islandCacheInstrumentation.tileCycles=VoxelForgeCoreShared::ReadCpuCycles()
+                -islandCacheInstrumentation.tileStartCycles;
             out.diagnostics.islandLocalCacheHits=islandCacheInstrumentation.localHits;
             out.diagnostics.islandLocalCacheMisses=islandCacheInstrumentation.localMisses;
             out.diagnostics.islandLocalCacheConflictReplacements=
@@ -2172,6 +2176,73 @@ namespace VoxelForgeCore
                 islandCacheInstrumentation.shared.conflictReplacements;
             out.diagnostics.islandSharedCacheLockWaitNanoseconds=
                 islandCacheInstrumentation.shared.lockWaitNanoseconds;
+            const auto& a=islandCacheInstrumentation.attribution;
+            const auto Estimate=[](std::uint64_t cycles,std::uint64_t calls,
+                std::uint64_t samples)->std::uint64_t
+            {
+                return samples?static_cast<std::uint64_t>(
+                    static_cast<long double>(cycles)*calls/samples):0;
+            };
+            constexpr std::array<const char*,5> CallerNames={
+                "grid","skirt","boundary","filter","other"};
+            constexpr std::array<const char*,10> BucketNames={
+                "field","island","roots","connectors","helix","column",
+                "local_probe","shared_cache","mouth_filter","boundary"};
+            std::uint64_t sampledNativeCalls=0;
+            for(const auto samples:a.sampledNativeCalls)sampledNativeCalls+=samples;
+            std::ostringstream line;
+            line<<"[FiFieldAttribution] key=("<<key.coordinate.x<<","<<key.coordinate.y<<","<<key.coordinate.z
+                <<",lod"<<key.lod<<") tile_cycles="<<islandCacheInstrumentation.tileCycles
+                <<" sample_period=256 native_calls_est="<<sampledNativeCalls*256
+                <<" native_samples="<<sampledNativeCalls;
+            for(std::size_t i=0;i<a.sampledNativeCalls.size();++i)
+            {
+                line<<" native_"<<CallerNames[i]<<"="<<a.sampledNativeCalls[i]*256<<"/"
+                    <<a.sampledNativeCalls[i]<<"/"
+                    <<Estimate(a.nativeCycles[i],a.sampledNativeCalls[i]*256,
+                        a.sampledNativeCalls[i]);
+                line<<" field_"<<CallerNames[i]<<"="<<a.sampledFieldCalls[i]*256<<"/"
+                    <<a.sampledFieldCalls[i]<<"/"
+                    <<Estimate(a.fieldCycles[i],a.sampledFieldCalls[i]*256,
+                        a.sampledFieldCalls[i]);
+            }
+            for(std::size_t i=0;i<BucketNames.size();++i)
+                line<<" comp_"<<BucketNames[i]<<"="
+                    <<Estimate(a.exclusiveCycles[i],a.scopeSamples[i]*256,
+                        a.scopeSamples[i])
+                    <<"/"<<a.scopeSamples[i]<<"/"<<a.scopeSamples[i]*256;
+            const auto& shared=islandCacheInstrumentation.shared;
+            line<<" local_probe_calls="<<(islandCacheInstrumentation.localHits
+                    +islandCacheInstrumentation.localMisses)
+                <<" shared_calls_est="<<shared.sampledInitialReads*128
+                <<" shared_initial_read="<<shared.sampledInitialReads<<"/"
+                <<Estimate(shared.sampledInitialReadCycles,shared.sampledInitialReads*128,
+                    shared.sampledInitialReads)
+                <<" shared_locked_read="<<shared.sampledLockedReads<<"/"
+                <<Estimate(shared.sampledLockedReadCycles,shared.sampledLockedReads*128,
+                    shared.sampledLockedReads)
+                <<" shared_lock="<<shared.sampledLocks<<"/"
+                <<Estimate(shared.sampledLockCycles,shared.sampledLocks*128,
+                    shared.sampledLocks)
+                <<" shared_build="<<shared.sampledBuilds<<"/"
+                <<Estimate(shared.sampledBuildCycles,shared.sampledBuilds*128,
+                    shared.sampledBuilds)
+                <<" trace_sampled="<<a.traceSampledMisses
+                <<" trace_seen_before="<<a.traceSeenBefore
+                <<" trace_evictions="<<a.traceEvictions
+                <<" trace_reused_evictions="<<a.traceReusedEvictions
+                <<" trace_events="<<a.traceCount;
+            std::printf("%s\n",line.str().c_str());
+            for(std::size_t i=0;i<a.traceCount;++i)
+                std::printf("[FiReuseTrace] tile=(%d,%d,%d,lod%d) set=%llu island=%llu xy=(%lld,%lld) evicted_island=%llu evicted_xy=(%lld,%lld) flags=%u\n",
+                    key.coordinate.x,key.coordinate.y,key.coordinate.z,key.lod,
+                    static_cast<unsigned long long>(a.traceSet[i]),
+                    static_cast<unsigned long long>(a.traceIsland[i]),
+                    static_cast<long long>(a.traceX[i]),static_cast<long long>(a.traceY[i]),
+                    static_cast<unsigned long long>(a.traceEvictedIsland[i]),
+                    static_cast<long long>(a.traceEvictedX[i]),
+                    static_cast<long long>(a.traceEvictedY[i]),
+                    static_cast<unsigned>(a.traceFlags[i]));
         };
         out.diagnostics.featureRefinedResolution=bFeatureRefinedResolution;
         if(options.profileMesherStages)
@@ -2419,6 +2490,30 @@ namespace VoxelForgeCore
                         RelevantMinimum=std::min(RelevantMinimum,FeatureMinimum);
                         RelevantMaximum=std::max(RelevantMaximum,FeatureMaximum);
                     }
+                    // A resolved passage void column can add solid support above or
+                    // below the native heightfield's local Z range. Its finite radial
+                    // and vertical bounds must participate before the mesh band is clipped.
+                    for(const auto& Crossing:tileShape.GetPassageVoidCrossings())
+                    {
+                        if(!Crossing.needsColumn||Crossing.maximumRadiusSubvoxels<=0
+                            ||Crossing.topZSubvoxels<=Crossing.bottomZSubvoxels)continue;
+                        const double Radius=static_cast<double>(Crossing.maximumRadiusSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        const double CenterX=static_cast<double>(Crossing.centerXSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        const double CenterY=static_cast<double>(Crossing.centerYSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        if(CenterX+Radius<TileMinimum[0]/static_cast<double>(SubvoxelScale)
+                            ||CenterX-Radius>TileMaximum[0]/static_cast<double>(SubvoxelScale)
+                            ||CenterY+Radius<TileMinimum[1]/static_cast<double>(SubvoxelScale)
+                            ||CenterY-Radius>TileMaximum[1]/static_cast<double>(SubvoxelScale))continue;
+                        RelevantMinimum=std::min(RelevantMinimum,
+                            static_cast<double>(Crossing.bottomZSubvoxels)
+                                /static_cast<double>(SubvoxelScale));
+                        RelevantMaximum=std::max(RelevantMaximum,
+                            static_cast<double>(Crossing.topZSubvoxels)
+                                /static_cast<double>(SubvoxelScale));
+                    }
                     // The native heightfield band only covers the owner terrain and its
                     // manifest features. Resolved SDF stamps can carve below that band or
                     // add a floor there, so include every overlapping stamp's bounded Z