fix(unreal): U1 -- Unreal compiles again on L61; CoreGeometry asset section; versioned layout-unit upgrade

Windows MSVC catch-up after abyss L15-L61 (no Unreal there): 64-bit clipmap shift (C4334), qualified VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel, UHT metadata and duplicate-signature fixes. Optional CoreGeometry section on UVoxelStrateDefinition (native caves, lattice, profiled heightfields, named stamps, rooms/tunnels; off/empty by default), resolved after passage planning. VoxelForgeAssetVersion 2 converts strate height/transition/gap to metres on load (exact, 0 m change on the owner's 5 assets; packages never saved). Gates pass (SurfaceWorld, FloatingIslands, Core-off, M2, W1/W8/W16). KNOWN REGRESSION vs L14 (2026-10-20, same command, same PC): full set 3.9 -> 5.37 s, worker-seconds 15.8 -> 30, LOD0 1.11 -> 1.69 s, ring 0.50 -> 0.80 s; not yet attributed (Core L15-L61 vs Unreal side). Report: Standalone/Research/WorldAssemblerM3/Unreal1. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 12:12:08 +01:00
1 parent 32021930d2
commit fc9227f9e0
@@ -18023,6 +18023,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
    const double CarveBrushRadiusCoreVoxels =
        CarveBrushRadiusLegacyVoxels * static_cast<double>(VOXEL_SIZE) / CoreVoxelSizeCm;
    const int32 CollisionRadius = FMath::Clamp(AuthoredSettings->PawnCollisionRadiusChunks, 1, 4);
+    FIntVector ColdStartCollisionCenter = FIntVector::ZeroValue;
    uint64 ExpectedEditDigest = 0;
    std::array<std::uint64_t, 4> InitialAggregates{};
    std::array<std::uint64_t, 4> TravelAggregates{};
@@ -18208,10 +18209,17 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
            BiomeProbeSpanVoxels);

        VoxelForgeCore::World ReferenceWorld(std::move(*Snapshot));
-        const std::vector<VoxelForgeCore::TileKey> Desired = ReferenceWorld.desiredTiles({});
+        // Match the actor's cold-start fallback camera when the transient world has no pawn.
+        // Aligner la reference sur la camera de repli de l'acteur sans pawn au demarrage.
+        const VoxelForgeCore::WorldConfiguration& ReferenceConfiguration =
+            ReferenceWorld.configuration();
+        const VoxelForgeCore::Vec3d InitialCameraVoxels = ReferenceConfiguration.viewerStartFound
+            ? ReferenceConfiguration.viewerStartVoxels : VoxelForgeCore::Vec3d{};
+        const std::vector<VoxelForgeCore::TileKey> Desired =
+            ReferenceWorld.desiredTiles(InitialCameraVoxels);
        if (Desired.empty())
        {
-            OutError = TEXT("Standalone Core returned an empty reference clipmap at the origin.");
+            OutError = TEXT("Standalone Core returned an empty reference clipmap at the cold-start camera.");
            return false;
        }
        ExpectedInitialTileCount = Desired.size();
@@ -18258,7 +18266,23 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
                UTF8_TO_TCHAR(CoreError.c_str()));
            return false;
        }
-        ReferenceWorld.retainTileRegions(Desired);
+        // Match the runtime collision probe around the same cold-start viewer tile.
+        // Reproduire la sonde de collision autour de la meme tuile de depart a froid.
+        ColdStartCollisionCenter = FIntVector(
+            FMath::FloorToInt(InitialCameraVoxels.x / 32.0),
+            FMath::FloorToInt(InitialCameraVoxels.y / 32.0),
+            FMath::FloorToInt(InitialCameraVoxels.z / 32.0));
+        std::vector<VoxelForgeCore::TileKey> ColdStartCollisionTiles;
+        ColdStartCollisionTiles.reserve(static_cast<std::size_t>(2 * CollisionRadius + 1)
+            * static_cast<std::size_t>(2 * CollisionRadius + 1)
+            * static_cast<std::size_t>(2 * CollisionRadius + 1));
+        for (int32 Z = -CollisionRadius; Z <= CollisionRadius; ++Z)
+        for (int32 Y = -CollisionRadius; Y <= CollisionRadius; ++Y)
+        for (int32 X = -CollisionRadius; X <= CollisionRadius; ++X)
+            ColdStartCollisionTiles.push_back({
+                {ColdStartCollisionCenter.X + X,
+                 ColdStartCollisionCenter.Y + Y,
+                 ColdStartCollisionCenter.Z + Z}, 0});

        if (Arguments.bCoreHybridCliffOnly)
        {
@@ -18332,6 +18356,47 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
            Options.mesherRecipe = VoxelForgeCore::MesherRecipe::worldAssemblerHybridV1;
        else
            Options.mesherRecipe = VoxelForgeCore::MesherRecipe::marchingCubesV1;
+
+        // Keep collision hashes outside ExpectedInitialDesiredSet; the collision cube is an
+        // additional runtime request even where it overlaps the visual clipmap.
+        // Garder les hachages de collision hors de l'ensemble visuel initial, meme s'ils se
+        // recoupent avec le clipmap.
+        std::vector<VoxelForgeCore::TileKey> RetainedReferenceTiles = Desired;
+        RetainedReferenceTiles.insert(RetainedReferenceTiles.end(),
+            ColdStartCollisionTiles.begin(), ColdStartCollisionTiles.end());
+        ReferenceWorld.retainTileRegions(RetainedReferenceTiles);
+        if (!ReferenceWorld.compileTileRegion(ColdStartCollisionTiles, 16, Scheduler, CoreError))
+        {
+            OutError = FString::Printf(TEXT("Standalone collision reference compile failed: %s"),
+                UTF8_TO_TCHAR(CoreError.c_str()));
+            return false;
+        }
+        std::size_t CollisionBodyTiles = 0;
+        for (const VoxelForgeCore::TileKey& Key : ColdStartCollisionTiles)
+        {
+            const std::optional<VoxelForgeCore::TileMesh> Mesh =
+                ReferenceWorld.generateTile(Key, Options, CoreError);
+            if (!Mesh)
+            {
+                OutError = FString::Printf(TEXT("Standalone collision tile generation failed: %s"),
+                    UTF8_TO_TCHAR(CoreError.c_str()));
+                return false;
+            }
+            FVoxelForgeCoreTileHashRecord Record;
+            Record.bEmpty = Mesh->indices.empty();
+            Record.bHasHashes = Mesh->hasDensityHash && Mesh->hasMeshHash
+                && Mesh->hasPayloadHash && Mesh->hasTopologyHash;
+            if (!Record.bEmpty) ++CollisionBodyTiles;
+            ExpectedHashes.Add(FVoxelTileKey(
+                FIntVector(Key.coordinate.x, Key.coordinate.y, Key.coordinate.z), Key.lod), Record);
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeCoreWorldTest] standalone_collision_reference=1 center=(%d,%d,%d) tiles=%d body=%llu no_body=%llu"),
+            ColdStartCollisionCenter.X, ColdStartCollisionCenter.Y, ColdStartCollisionCenter.Z,
+            static_cast<int32>(ColdStartCollisionTiles.size()),
+            static_cast<unsigned long long>(CollisionBodyTiles),
+            static_cast<unsigned long long>(ColdStartCollisionTiles.size() - CollisionBodyTiles));
+
        std::vector<FStandaloneCoreAdapterTileHashes> AggregateRows;
        AggregateRows.reserve(Desired.size());
        bool bFoundCarveVertex = false;
@@ -19367,7 +19432,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
    for (int32 Y = -CollisionRadius; Y <= CollisionRadius; ++Y)
    for (int32 X = -CollisionRadius; X <= CollisionRadius; ++X)
    {
-        const FVoxelTileKey Key(FIntVector(X, Y, Z), 0);
+        const FVoxelTileKey Key(ColdStartCollisionCenter + FIntVector(X, Y, Z), 0);
        ExpectedCollisionSet.Add(Key);
        const FVoxelForgeCoreTileHashRecord* Record = ExpectedHashes.Find(Key);
        if (Record == nullptr)
@@ -21361,6 +21426,44 @@ int32 RunBatch(const FString& Params)

 int32 UVoxelForgeExploreCommandlet::Main(const FString& Params)
 {
+    if (FParse::Param(*Params, TEXT("coreassetupgradeaudit")))
+    {
+        // Load the untouched BuildHost copies and emit their in-memory conversions; never save a package.
+        // Charge les copies BuildHost intactes et affiche les conversions en memoire, sans sauver de package.
+        UVoxelSettings* SettingsAsset = LoadObject<UVoxelSettings>(nullptr,
+            TEXT("/Game/VoxelForge/DA_Settings.DA_Settings"));
+        if (SettingsAsset == nullptr)
+        {
+            UE_LOG(LogTemp, Error, TEXT("[VoxelForgeAssetMigrationAudit] missing DA_Settings copy"));
+            return 2;
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeAssetMigrationAudit] asset=%s old_gap_chunks=%d new_gap_m=%.6f layout_chunk_m=%.6f"),
+            *SettingsAsset->GetPathName(), SettingsAsset->InterStrateGapChunks,
+            SettingsAsset->InterStrateGapMeters, SettingsAsset->StrateLayoutChunkSizeMeters);
+
+        const TCHAR* StratePaths[] = {
+            TEXT("/Game/VoxelForge/DA_Strate1.DA_Strate1"),
+            TEXT("/Game/VoxelForge/DA_Strate2.DA_Strate2"),
+            TEXT("/Game/VoxelForge/DA_Strate3.DA_Strate3"),
+            TEXT("/Game/VoxelForge/DA_Strate4.DA_Strate4")
+        };
+        for (const TCHAR* Path : StratePaths)
+        {
+            UVoxelStrateDefinition* Definition = LoadObject<UVoxelStrateDefinition>(nullptr, Path);
+            if (Definition == nullptr)
+            {
+                UE_LOG(LogTemp, Error, TEXT("[VoxelForgeAssetMigrationAudit] missing strate copy %s"), Path);
+                return 2;
+            }
+            UE_LOG(LogTemp, Display,
+                TEXT("[VoxelForgeAssetMigrationAudit] asset=%s old_height_chunks=%d new_height_m=%.6f old_transition_chunks=%d new_transition_m=%.6f"),
+                *Definition->GetPathName(), Definition->StrateHeightInChunks,
+                Definition->StrateHeightMeters, Definition->TransitionBlendChunks,
+                Definition->TransitionWidthMeters);
+        }
+        return 0;
+    }
    if (FParse::Param(*Params, TEXT("step2f")))
    {
        return RunStep2f(Params);