wip(step3): 12.5 cm voxels, fall-through fixed, brick evaluator in game, organic tunnels -- speed gate FAILS

Stopped by the owner's decision (in-game lit captures were eating the round); he judges the look in
game instead.
1. Fall-through with the research field: fixed. Deep drop, gate on: 2 holds (0.50 s), min foot
   clearance +43 cm; gate off: penetrates (-278 cm). Stress fixture offsets converted to metres.
2. VOXEL_SIZE 25 -> 12.5 cm. Physical sizes kept in metres (player, steps, gate, insets, research
   field sizes, dig radii, test thresholds); class defaults that count chunks/voxels doubled
   (ClipRadius 6, RenderDistanceChunks 1536, ViewDistance*, StrateViewMargin 6,
   PawnCollisionRadius 2, SkirtCells 4, EdgeSealThickness 128, decoration spacings, density volume
   res 256). Asset values override these defaults: the owner must double his own.
   Ring scale, six workers, idle, step-2f field before the look changes: 64 m cube (519^3) 4.55 s;
   32 m cube (259^3) 0.95 s.
3. In game: tiles go through the brick evaluator (proved by a log marker); profile switch rebuilds
   the loaded world (~5,800 tiles); full-detail fill 12.4 s after spawn in the visible-window test.
4. Look: round winding tunnels, per-column ellipsoid/lattice caches. All step-2f geometry gates pass
   at 12.5 cm (0 crumbs, 1 solid component per profile, solid share 69-87%). 259^3 ring, six workers:
   1.08-2.02 s (worst HyperComplex) -- the 600 ms gate FAILS. Lit captures failed (hidden/off-screen
   window, then blank frames); not pursued.

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

Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp

@@ -4,11 +4,16 @@
 #include "VoxelMarchingCubesMesher.h"
 #include "MarchingCubesTables.h"
 #include "VoxelDensityProfile.h"
+#if WITH_EDITOR
+#include "VoxelRedefinedDensityField.h"
+#endif
 #include "VoxelStrateManager.h"
 #include "VoxelTilePostReach.h"
+#include "VoxelPassageGeometry.h"
 #include "ProfilingDebugging/CpuProfilerTrace.h"
 #include "HAL/IConsoleManager.h"
 #include "Misc/CommandLine.h"
+#include <atomic>
 
 namespace
 {
@@ -703,7 +708,16 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
     // gradient) sont échantillonnées — le reste du tampon reste non initialisé et non lu.
     VoxelDensityProfile::FScopedTimer MesherDensityGridTimer(
         VoxelDensityProfile::EBucket::MesherDensityGrid);
+#if WITH_EDITOR
+    const bool bUseParameterizedBrickEvaluator =
+        VoxelForgeRedefinedDensityField::IsParameterizedEnabled()
+        && !bUseSharedDensityGrid && !bCapturePreEditGrid
+        && OutCaptureGrid == nullptr;
+#else
+    constexpr bool bUseParameterizedBrickEvaluator = false;
+#endif
     const bool bUseOperatorBlock = !bUseSharedDensityGrid
+        && !bUseParameterizedBrickEvaluator
         && GVoxelForgeUseOperatorBlock != 0;
     if (bUseOperatorBlock)
     {
@@ -713,7 +727,149 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
             OriginVoxels + FIntVector(-Step, -Step, GzLo * Step),
             Step, MDim, MDim, GzHi - GzLo + 1);
     }
-    for (int32 gz = GzLo; gz <= GzHi; gz++)
+    if (bUseParameterizedBrickEvaluator)
+    {
+#if WITH_EDITOR
+        static std::atomic<bool> bLoggedParameterizedBrickRoute{false};
+        if (!bLoggedParameterizedBrickRoute.exchange(true, std::memory_order_relaxed))
+        {
+            UE_LOG(LogTemp, Display,
+                TEXT("[VoxelForgeResearchBrickEvaluator] mesher_grid=1 brick_samples=%d detail_scale=%.6f"),
+                VoxelForgeRedefinedDensityField::ParameterizedBrickSamples,
+                VoxelForgeRedefinedDensityField::GetDetailScale());
+        }
+        constexpr int32 ResearchBrickSamples =
+            VoxelForgeRedefinedDensityField::ParameterizedBrickSamples;
+        const float DetailScale = VoxelForgeRedefinedDensityField::GetDetailScale();
+        TArray<float> DetailBrick;
+        TArray<float> BrickValues;
+        TArray<float> ColumnValues;
+        TArray<uint8> ProofKinds;
+        VoxelForgeRedefinedDensityField::FParameterizedBrickContext BrickContext;
+        const int32 GridZSamples = GzHi - GzLo + 1;
+        const int32 ProofZCount = FMath::DivideAndRoundUp(GridZSamples, ResearchBrickSamples);
+        ProofKinds.SetNumUninitialized(ProofZCount);
+        for (int32 BrickY = 0; BrickY < MDim; BrickY += ResearchBrickSamples)
+        for (int32 BrickX = 0; BrickX < MDim; BrickX += ResearchBrickSamples)
+        {
+            if (ShouldAbortWork())
+            {
+                return FVoxelMeshData();
+            }
+            const int32 BrickSizeX = FMath::Min(ResearchBrickSamples, MDim - BrickX);
+            const int32 BrickSizeY = FMath::Min(ResearchBrickSamples, MDim - BrickY);
+            for (int32 ProofZ = 0; ProofZ < ProofZCount; ++ProofZ)
+            {
+                if (ShouldAbortWork())
+                {
+                    return FVoxelMeshData();
+                }
+                const int32 BrickZ = ProofZ * ResearchBrickSamples;
+                const FIntVector ProofSize(
+                    BrickSizeX, BrickSizeY,
+                    FMath::Min(ResearchBrickSamples, GridZSamples - BrickZ));
+                const FIntVector ProofOrigin = OriginVoxels + FIntVector(
+                    (BrickX - 1) * Step,
+                    (BrickY - 1) * Step,
+                    (GzLo + BrickZ) * Step);
+
+                bool bUniformAir = false;
+                if (VoxelForgeRedefinedDensityField::TryClassifyParameterizedBrick(
+                        *Generator, ProofOrigin, ProofSize, bUniformAir, DetailScale,
+                        nullptr, nullptr, Step))
+                {
+                    ProofKinds[ProofZ] = bUniformAir ? 1 : 2;
+                    const float UniformDensity = bUniformAir
+                        ? VoxelForgeRedefinedDensityField::ParameterizedUniformDensity
+                        : -VoxelForgeRedefinedDensityField::ParameterizedUniformDensity;
+                    for (int32 Z = 0; Z < ProofSize.Z; ++Z)
+                    for (int32 Y = 0; Y < ProofSize.Y; ++Y)
+                    for (int32 X = 0; X < ProofSize.X; ++X)
+                    {
+                        const int32 GX = BrickX + X - 1;
+                        const int32 GY = BrickY + Y - 1;
+                        const int32 GZ = GzLo + BrickZ + Z;
+                        const int32 LocalIndex =
+                            ((GZ + 1) * MDim + (GY + 1)) * MDim + (GX + 1);
+                        DensityGrid[LocalIndex] = UniformDensity;
+                    }
+                }
+                else
+                {
+                    ProofKinds[ProofZ] = 0;
+                }
+            }
+
+            for (int32 ProofZ = 0; ProofZ < ProofZCount;)
+            {
+                if (ProofKinds[ProofZ] != 0)
+                {
+                    ++ProofZ;
+                    continue;
+                }
+                if (ShouldAbortWork())
+                {
+                    return FVoxelMeshData();
+                }
+
+                const int32 FirstMixedProofZ = ProofZ;
+                const int32 BrickZ = FirstMixedProofZ * ResearchBrickSamples;
+                const int32 FirstWorldZ = OriginVoxels.Z + (GzLo + BrickZ) * Step;
+                const int32 FirstChunkZ = FMath::FloorToInt(
+                    static_cast<float>(FirstWorldZ) / CHUNK_SIZE);
+                int32 RunProofCount = 1;
+                int32 RunSampleCount = FMath::Min(
+                    ResearchBrickSamples, GridZSamples - BrickZ);
+                while (ProofZ + RunProofCount < ProofZCount
+                    && ProofKinds[ProofZ + RunProofCount] == 0)
+                {
+                    const int32 CandidateSampleCount = FMath::Min(
+                        (RunProofCount + 1) * ResearchBrickSamples,
+                        GridZSamples - BrickZ);
+                    const int32 CandidateEndZ = FirstWorldZ
+                        + (CandidateSampleCount - 1) * Step;
+                    const int32 CandidateChunkZ = FMath::FloorToInt(
+                        static_cast<float>(CandidateEndZ) / CHUNK_SIZE);
+                    if (CandidateSampleCount > FMath::Max(1, CHUNK_SIZE / Step)
+                        || CandidateChunkZ != FirstChunkZ)
+                    {
+                        break;
+                    }
+                    ++RunProofCount;
+                    RunSampleCount = CandidateSampleCount;
+                }
+
+                const FIntVector BrickSize(BrickSizeX, BrickSizeY, RunSampleCount);
+                const FIntVector BrickOrigin = OriginVoxels + FIntVector(
+                    (BrickX - 1) * Step,
+                    (BrickY - 1) * Step,
+                    (GzLo + BrickZ) * Step);
+                VoxelForgeRedefinedDensityField::EvaluateParameterizedDensityBrick(
+                    *Generator, BrickOrigin, BrickSize, DetailScale, BrickContext,
+                    DetailBrick, ColumnValues, BrickValues, Step);
+                for (int32 Z = 0; Z < BrickSize.Z; ++Z)
+                for (int32 Y = 0; Y < BrickSize.Y; ++Y)
+                for (int32 X = 0; X < BrickSize.X; ++X)
+                {
+                    const int32 GX = BrickX + X - 1;
+                    const int32 GY = BrickY + Y - 1;
+                    const int32 GZ = GzLo + BrickZ + Z;
+                    const int32 LocalIndex =
+                        ((GZ + 1) * MDim + (GY + 1)) * MDim + (GX + 1);
+                    DensityGrid[LocalIndex] =
+                        BrickValues[(Z * BrickSize.Y + Y) * BrickSize.X + X];
+                }
+                if (OutDensitySampleCount != nullptr)
+                {
+                    *OutDensitySampleCount += static_cast<int64>(
+                        BrickSize.X * BrickSize.Y * BrickSize.Z);
+                }
+                ProofZ += RunProofCount;
+            }
+        }
+#endif
+    }
+    else for (int32 gz = GzLo; gz <= GzHi; gz++)
     {
         if (ShouldAbortWork())
         {