Fr0zka/VoxelForge
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
26984d38d8214976453755df77b5e68f4c63e151
VoxelForge/Source/VoxelForge/Private/VoxelStrateManager.cpp
T
Claude 26984d38d8 docs(comments): drop history narration, keep the why 
Rewrite comments that told the story of past rounds instead of the
current code: dated "fixed on / tried on / reverted on" notes, "this used
to...", "stale paragraph removed", "Phase 1/2" progress labels, and the
"ClassifyTile still does not use ClassifyBox" claim (it does now, via
VF_ClassifyBoxWithWarpRetry). Every invariant, unit, sign convention,
trap and measurement that justified the design is kept, rephrased in the
present tense and in its original language (French or English).

Also fix comments that named symbols removed in the dead-code commit
(EvaluateSDF wrapper, FTunnelCoreWorldEvaluation support-floor fields,
BlendChunks -> TransitionBlendChunks) and the stale function name in the
VF_RollStrateParamsDetailed determinism checkf message.

Comment and message text only; no code token changed. Tests untouched.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01URDGLsu7c4nunqNFPJEFPU
2026-09-28 14:18:36 +00:00

6926 lines
300 KiB
C++
Raw Blame History

// VoxelStrateManager.cpp
// Runtime strate layout generation and queries.
#include "VoxelStrateManager.h"
#include "CoreGlobals.h" // GIsAutomationTesting — the opt-in diagnostic stays quiet under tests
#include "VoxelSettings.h"
#include "VoxelSeasonAsset.h"
#include "VoxelTypes.h" // For CHUNK_SIZE, VOXEL_SIZE, WorldToChunkCoord
#include "VoxelCaveMorphology.h" // For VoxelSDF and VoxelHash
#include "VoxelDensityPrimitives.h" // Shared passage carve polarity/strength
#include "VoxelDensityAblation.h" // Fingerprinted development-only stage overrides
#include "VoxelDensityProfile.h" // Opt-in targeted per-voxel attribution
#include "VoxelStartupTrace.h"
#include "VoxelTerrainOpDefinition.h" // For UVoxelTerrainOpDefinition::ApplyTo
#include "VoxelBiomeDefinition.h" // For UVoxelBiomeDefinition (biome context flatten)
#include "HAL/IConsoleManager.h"
#include "Misc/CommandLine.h"
#include "Misc/Crc.h"
#include "Misc/Parse.h"
#include "UObject/UObjectGlobals.h"
#include <atomic>
namespace
{
std::atomic<uint64> GNextStrateManagerLifetimeId { 0 };
// Exact A/B switch for the repeated passage-floor projection item. The other field-
// preserving rewrites in this round are deliberately unconditional; this switch isolates
// the projection reuse without changing any density arithmetic.
int32 GVoxelForgeFloorRound1PassageProjectionCache = 1;
FAutoConsoleVariableRef CVarVoxelForgeFloorRound1PassageProjectionCache(
TEXT("voxel.FloorRound1PassageProjectionCache"),
GVoxelForgeFloorRound1PassageProjectionCache,
TEXT("Reuse exact passage floor projections within one density sample; 0 disables the A/B cache."));
// This is a measurement override only. The asset-owned bEnableWorms field remains the real
// per-strate contract; this process-wide switch exists so the game harness can measure the
// cost of enabled versus disabled worms without editing an owner's asset. It is resolved once
// before generation params are published so workers cannot disagree mid-world.
int32 GVoxelForgeWormsForceOff = 0;
std::atomic<int32> GResolvedWormsForceOff(-1);
FAutoConsoleVariableRef CVarVoxelForgeWormsForceOff(
TEXT("voxel.WormsForceOff"),
GVoxelForgeWormsForceOff,
TEXT("WORLD-CHANGING DEVELOPMENT-ONLY measurement override. 0=asset behavior, 1=force "
"all worm strengths to zero. Never vary this between multiplayer peers or world "
"regenerations; it is not the per-strate off switch."),
ECVF_Default);
bool VF_WormsForceOff()
{
int32 Existing = GResolvedWormsForceOff.load(std::memory_order_acquire);
if (Existing >= 0)
{
return Existing != 0;
}
int32 CommandLineValue = GVoxelForgeWormsForceOff;
FParse::Value(
FCommandLine::Get(), TEXT("voxel.WormsForceOff="), CommandLineValue);
const int32 Resolved = CommandLineValue != 0 ? 1 : 0;
int32 Expected = -1;
if (!GResolvedWormsForceOff.compare_exchange_strong(
Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
{
return Expected != 0;
}
GVoxelForgeWormsForceOff = Resolved;
return Resolved != 0;
}
struct FRuntimeRoughnessOverrides
{
bool bSurfaceRoughness = false;
float SurfaceRoughness = 0.0f;
bool bFrequency = false;
float Frequency = 0.0f;
bool bNoiseType = false;
EVoxelNoiseType NoiseType = EVoxelNoiseType::FBM;
};
const FRuntimeRoughnessOverrides& VF_GetRuntimeRoughnessOverrides()
{
// These are diagnostic command-line inputs, captured once per process. Keeping the
// override at the params boundary makes every chunk, classifier, and mesher see the same
// immutable values without putting a command-line parse in the voxel hot loop.
static const FRuntimeRoughnessOverrides Overrides = []()
{
FRuntimeRoughnessOverrides Result;
const FString CommandLine(FCommandLine::Get());
Result.bSurfaceRoughness = FParse::Value(
*CommandLine, TEXT("voxel.surfaceroughness="), Result.SurfaceRoughness);
if (Result.bSurfaceRoughness
&& (!VoxelMath::IsFinite(Result.SurfaceRoughness) || Result.SurfaceRoughness < 0.0f))
{
Result.bSurfaceRoughness = false;
}
Result.bFrequency = FParse::Value(
*CommandLine, TEXT("voxel.roughnessfrequency="), Result.Frequency);
if (Result.bFrequency
&& (!VoxelMath::IsFinite(Result.Frequency) || Result.Frequency <= 0.0f))
{
Result.bFrequency = false;
}
FString NoiseTypeText;
if (FParse::Value(
*CommandLine, TEXT("voxel.roughnesstype="), NoiseTypeText))
{
NoiseTypeText.TrimStartAndEndInline();
NoiseTypeText.ToLowerInline();
NoiseTypeText.ReplaceInline(TEXT("_"), TEXT(""));
NoiseTypeText.ReplaceInline(TEXT("-"), TEXT(""));
if (NoiseTypeText == TEXT("fbm") || NoiseTypeText == TEXT("fractal"))
{
Result.NoiseType = EVoxelNoiseType::FBM;
Result.bNoiseType = true;
}
else if (NoiseTypeText == TEXT("ridged") || NoiseTypeText == TEXT("ridge"))
{
Result.NoiseType = EVoxelNoiseType::Ridged;
Result.bNoiseType = true;
}
else if (NoiseTypeText == TEXT("mixed"))
{
Result.NoiseType = EVoxelNoiseType::Mixed;
Result.bNoiseType = true;
}
else if (NoiseTypeText == TEXT("cellular") || NoiseTypeText == TEXT("worley"))
{
Result.NoiseType = EVoxelNoiseType::Cellular;
Result.bNoiseType = true;
}
}
if (Result.bSurfaceRoughness || Result.bFrequency || Result.bNoiseType)
{
UE_LOG(LogTemp, Display,
TEXT("[StrateManager] Runtime roughness override: strength=%s%.3f frequency=%s%.6f type=%s"),
Result.bSurfaceRoughness ? TEXT("") : TEXT("(asset) "),
Result.SurfaceRoughness,
Result.bFrequency ? TEXT("") : TEXT("(asset) "),
Result.Frequency,
Result.bNoiseType
? (Result.NoiseType == EVoxelNoiseType::FBM ? TEXT("FBM")
: Result.NoiseType == EVoxelNoiseType::Ridged ? TEXT("Ridged")
: Result.NoiseType == EVoxelNoiseType::Mixed ? TEXT("Mixed")
: TEXT("Cellular"))
: TEXT("(asset)"));
}
return Result;
}();
return Overrides;
}
static FStrateGenerationParams VF_ApplyRuntimeRoughnessOverrides(
FStrateGenerationParams Params)
{
const FRuntimeRoughnessOverrides& Overrides = VF_GetRuntimeRoughnessOverrides();
if (Overrides.bSurfaceRoughness)
{
Params.SurfaceRoughness = Overrides.SurfaceRoughness;
}
if (Overrides.bFrequency)
{
Params.RoughnessFrequency = Overrides.Frequency;
}
if (Overrides.bNoiseType)
{
Params.RoughnessNoiseType = Overrides.NoiseType;
}
return Params;
}
}
UVoxelStrateManager::UVoxelStrateManager()
: CacheLifetimeId(GNextStrateManagerLifetimeId.fetch_add(1, std::memory_order_relaxed) + 1)
{
}
#if WITH_EDITOR
#include "VoxelStrateComposer.h"
struct FVoxelStrateComposerSlotOverride
{
int32 CandidateSeed = 0;
ECaveGeneratorType Archetype = ECaveGeneratorType::TunnelNetwork;
FVoxelStrateArchetypeParams Params;
bool bUseRecipe = false;
FVoxelOpStackRecipe Recipe;
bool bUseRegions = false;
FVoxelStrateRegionManifest Regions;
};
static void VF_SetComposerRuntimeBounds(
FVoxelStrateArchetypeParams& Params, float TopWorldZ, float BottomWorldZ)
{
Params.TunnelNetworkParams.StrateTopWorldZ = TopWorldZ;
Params.TunnelNetworkParams.StrateBottomWorldZ = BottomWorldZ;
Params.SlabParams.StrateTopWorldZ = TopWorldZ;
Params.SlabParams.StrateBottomWorldZ = BottomWorldZ;
Params.MazeParams.StrateTopWorldZ = TopWorldZ;
Params.MazeParams.StrateBottomWorldZ = BottomWorldZ;
Params.SurfaceParams.StrateTopWorldZ = TopWorldZ;
Params.SurfaceParams.StrateBottomWorldZ = BottomWorldZ;
Params.VerticalShaftParams.StrateTopWorldZ = TopWorldZ;
Params.VerticalShaftParams.StrateBottomWorldZ = BottomWorldZ;
Params.FloatingIslandParams.StrateTopWorldZ = TopWorldZ;
Params.FloatingIslandParams.StrateBottomWorldZ = BottomWorldZ;
}
#endif
// Fractal Brownian Motion (layered Perlin) along a 1D parameter, ~[-1,1].
// Independent octaves at increasing frequency / decreasing amplitude give an organic,
// non-repeating wander — the key to a worm that SQUIRMS instead of zig-zagging (1D) or
// orbiting (single-octave 2-channel = a spiral). Each axis samples this with its own seed.
static float PassageFBM(float X, float Seed)
{
float Total = 0.0f, Amp = 1.0f, Freq = 1.0f, MaxV = 0.0f;
for (int32 O = 0; O < 4; ++O)
{
Total += FMath::PerlinNoise3D(FVector(X * Freq + Seed, Seed * 1.7f + O * 13.0f, O * 5.0f)) * Amp;
MaxV += Amp;
Amp *= 0.5f;
Freq *= 2.0f;
}
return (MaxV > 0.0f) ? (Total / MaxV) : 0.0f;
}
namespace
{
// One projection result per passage is enough for the current voxel sample. The surrounding
// passage cache already moves with (manager, layout, chunk); a generation invalidates old flags
// before any caller can observe them. Keeping the entries indexed by passage avoids a TMap
// rehash path in this hot loop, while a collision-free hit remains exact.
struct FPassageFloorProjectionCacheEntry
{
// The sample key lives once in FPassageEvaluationCache. A monotonically increasing
// generation makes an entry's old flags inert without clearing its float payload.
// The payload is only read after the corresponding valid flag is set.
uint64 SampleGeneration = 0;
uint8 ComputedFlags = 0;
bool bNativeValid = false;
float NativeFloorZ = 0.0f;
float NativeSupportRadius = 0.0f;
bool bGenericValid = false;
float GenericFloorZ = 0.0f;
float GenericSupportRadius = 0.0f;
bool bWalkableAir = false;
enum : uint8
{
NativeComputed = 1u << 0,
GenericComputed = 1u << 1,
WalkableAirComputed = 1u << 2
};
FORCEINLINE bool Has(uint8 Flag) const
{
return (ComputedFlags & Flag) != 0;
}
FORCEINLINE void SetComputed(uint8 Flag)
{
ComputedFlags |= Flag;
}
};
/**
* One shared passage cache for the tube SDF and landing-floor fill.
*
* The source query and all landing dimensions are resolved by GeneratePassages. This cache
* only narrows the immutable passage array once per (manager, version, chunk); neither the
* player-fit stencil nor a topology search can leak into the voxel loop.
*/
struct FPassageEvaluationCache
{
const UVoxelStrateManager* Owner = nullptr;
uint64 OwnerLifetimeId = 0;
FIntVector Chunk = FIntVector(INT32_MAX, INT32_MAX, INT32_MAX);
uint32 Version = 0xFFFFFFFFu;
TArray<int32> Nearby;
TArray<FPassageFloorProjectionCacheEntry> FloorProjections;
bool bFloorProjectionSampleValid = false;
double FloorProjectionX = 0.0;
double FloorProjectionY = 0.0;
double FloorProjectionZ = 0.0;
uint64 FloorProjectionGeneration = 0;
};
FPassageEvaluationCache& VF_GetPassageEvaluationCache()
{
thread_local FPassageEvaluationCache Cache;
return Cache;
}
const TArray<int32>& VF_GetNearbyPassages(
const UVoxelStrateManager* Manager,
const FIntVector& ChunkCoord)
{
FPassageEvaluationCache& Cache = VF_GetPassageEvaluationCache();
const uint32 Version = Manager ? Manager->GetLayoutVersion() : 0u;
const uint64 LifetimeId = Manager ? Manager->GetCacheLifetimeId() : 0;
if (Cache.Owner == Manager && Cache.OwnerLifetimeId == LifetimeId
&& Cache.Chunk == ChunkCoord && Cache.Version == Version)
{
return Cache.Nearby;
}
Cache.Owner = Manager;
Cache.OwnerLifetimeId = LifetimeId;
Cache.Chunk = ChunkCoord;
Cache.Version = Version;
Cache.Nearby.Reset();
Cache.FloorProjections.Reset();
Cache.bFloorProjectionSampleValid = false;
if (!Manager) return Cache.Nearby;
const FVector ChunkCenter(
(ChunkCoord.X + 0.5f) * (float)CHUNK_SIZE,
(ChunkCoord.Y + 0.5f) * (float)CHUNK_SIZE,
(ChunkCoord.Z + 0.5f) * (float)CHUNK_SIZE);
const float ChunkRadius = (float)CHUNK_SIZE * 0.8660254f + 3.0f;
const TArray<FVoxelPassage>& Passages = Manager->GetPassages();
Cache.FloorProjections.SetNum(Passages.Num());
for (int32 PassageIndex = 0; PassageIndex < Passages.Num(); ++PassageIndex)
{
const FVoxelPassage& Passage = Passages[PassageIndex];
const float Reach = Passage.BoundRadius + ChunkRadius;
if (FVector::DistSquared(ChunkCenter, Passage.BoundCenter) <= Reach * Reach)
{
Cache.Nearby.Add(PassageIndex);
}
}
return Cache.Nearby;
}
FPassageFloorProjectionCacheEntry* VF_GetPassageFloorProjectionCacheEntry(
const UVoxelStrateManager* Manager,
const FVector& Position,
int32 PassageIndex)
{
if (GVoxelForgeFloorRound1PassageProjectionCache == 0
|| Manager == nullptr || PassageIndex < 0)
{
return nullptr;
}
FPassageEvaluationCache& Cache = VF_GetPassageEvaluationCache();
if (Cache.Owner != Manager
|| Cache.OwnerLifetimeId != Manager->GetCacheLifetimeId()
|| Cache.Version != Manager->GetLayoutVersion()
|| PassageIndex >= Cache.FloorProjections.Num())
{
return nullptr;
}
if (!Cache.bFloorProjectionSampleValid
|| Cache.FloorProjectionX != Position.X
|| Cache.FloorProjectionY != Position.Y
|| Cache.FloorProjectionZ != Position.Z)
{
Cache.bFloorProjectionSampleValid = true;
Cache.FloorProjectionX = Position.X;
Cache.FloorProjectionY = Position.Y;
Cache.FloorProjectionZ = Position.Z;
++Cache.FloorProjectionGeneration;
if (Cache.FloorProjectionGeneration == 0)
{
// Keep generation zero reserved for never-initialized entries. This is
// unreachable in a practical worker lifetime, but preserves the invariant if a
// process survives long enough to wrap the counter.
for (FPassageFloorProjectionCacheEntry& Candidate : Cache.FloorProjections)
{
Candidate.SampleGeneration = 0;
}
++Cache.FloorProjectionGeneration;
}
}
FPassageFloorProjectionCacheEntry* Entry =
Cache.FloorProjections.GetData() + PassageIndex;
if (Entry->SampleGeneration != Cache.FloorProjectionGeneration)
{
Entry->SampleGeneration = Cache.FloorProjectionGeneration;
Entry->ComputedFlags = 0;
}
return Entry;
}
// Passage relief is a function of the immutable passage descriptor and the actual XY column.
// Keep the cache fixed-size and thread-local, like the morphology floor cache: a long export
// cannot retain one entry per tile, and collisions only lose a hit. Fractional normal
// samples intentionally fall through to the exact same two-octave calculation.
struct FVoxelPassageReliefCacheEntry
{
const UVoxelStrateManager* Owner = nullptr;
uint64 OwnerLifetimeId = 0;
uint32 LayoutVersion = 0;
int32 PassageIndex = INDEX_NONE;
int32 X = 0;
int32 Y = 0;
float Noise = 0.0f;
bool bValid = false;
};
struct FVoxelPassageReliefCache
{
static constexpr int32 Capacity = 16384;
static_assert((Capacity & (Capacity - 1)) == 0,
"passage relief cache must be a power of two");
FVoxelPassageReliefCacheEntry Entries[Capacity];
static uint32 HashKey(
const UVoxelStrateManager* Owner, uint64 LifetimeId, uint32 Version,
int32 PassageIndex, int32 X, int32 Y)
{
uint32 Hash = static_cast<uint32>(reinterpret_cast<UPTRINT>(Owner));
Hash ^= static_cast<uint32>(reinterpret_cast<UPTRINT>(Owner) >> 32);
const auto Combine = [&Hash](uint32 Value)
{
Hash ^= Value + 0x9E3779B9u + (Hash << 6) + (Hash >> 2);
};
Combine(static_cast<uint32>(LifetimeId));
Combine(static_cast<uint32>(LifetimeId >> 32));
Combine(Version);
Combine(static_cast<uint32>(PassageIndex));
Combine(static_cast<uint32>(X));
Combine(static_cast<uint32>(Y));
return VoxelHash::Mix(Hash);
}
};
FVoxelPassageReliefCache& VF_GetPassageReliefCache()
{
thread_local FVoxelPassageReliefCache Cache;
return Cache;
}
FORCEINLINE float VF_ComputePassageReliefNoise(
double X, double Y, uint32 FloorSeed, float Frequency)
{
const float SF = static_cast<float>(FloorSeed) * 0.00001f;
float Noise = FMath::PerlinNoise2D(
FVector2D(
static_cast<float>(X) * Frequency + SF,
static_cast<float>(Y) * Frequency + SF * 1.7f)) * 0.65f;
Noise += FMath::PerlinNoise2D(
FVector2D(
static_cast<float>(X) * Frequency * 2.3f + SF * 3.1f,
static_cast<float>(Y) * Frequency * 2.3f + SF * 5.3f)) * 0.35f;
return Noise;
}
FORCEINLINE float VF_PassageReliefNoise(
const UVoxelStrateManager* Manager, int32 PassageIndex,
const FVoxelPassage& Passage, double X, double Y)
{
if (!(Passage.NativeFloorReliefStrength > 0.0f)
|| !VoxelMath::IsFinite(Passage.NativeFloorReliefStrength)
|| !VoxelMath::IsFinite(Passage.NativeFloorReliefFrequency)
|| !(FMath::Abs(Passage.NativeFloorReliefFrequency) > KINDA_SMALL_NUMBER))
{
return 0.0f;
}
const bool bInteger = VoxelMath::IsFinite(X) && VoxelMath::IsFinite(Y)
&& FMath::FloorToDouble(X) == X && FMath::FloorToDouble(Y) == Y
&& X >= static_cast<double>(MIN_int32) && X <= static_cast<double>(MAX_int32)
&& Y >= static_cast<double>(MIN_int32) && Y <= static_cast<double>(MAX_int32);
if (!bInteger || Manager == nullptr || PassageIndex == INDEX_NONE)
{
return VF_ComputePassageReliefNoise(
X, Y, Passage.NativeFloorSeed, Passage.NativeFloorReliefFrequency);
}
const int32 IX = FMath::FloorToInt(X);
const int32 IY = FMath::FloorToInt(Y);
FVoxelPassageReliefCache& Cache = VF_GetPassageReliefCache();
const uint64 LifetimeId = Manager->GetCacheLifetimeId();
const uint32 Version = Manager->GetLayoutVersion();
FVoxelPassageReliefCacheEntry& Entry = Cache.Entries[
FVoxelPassageReliefCache::HashKey(
Manager, LifetimeId, Version, PassageIndex, IX, IY)
& (FVoxelPassageReliefCache::Capacity - 1)];
if (Entry.bValid
&& Entry.Owner == Manager
&& Entry.OwnerLifetimeId == LifetimeId
&& Entry.LayoutVersion == Version
&& Entry.PassageIndex == PassageIndex
&& Entry.X == IX && Entry.Y == IY)
{
return Entry.Noise;
}
const float Noise = VF_ComputePassageReliefNoise(
X, Y, Passage.NativeFloorSeed, Passage.NativeFloorReliefFrequency);
Entry.Owner = Manager;
Entry.OwnerLifetimeId = LifetimeId;
Entry.LayoutVersion = Version;
Entry.PassageIndex = PassageIndex;
Entry.X = IX;
Entry.Y = IY;
Entry.Noise = Noise;
Entry.bValid = true;
return Noise;
}
}
namespace
{
// The graph-tunnel relief proof is intentionally repeated here instead of sharing a loose
// "noise amplitude" constant. The passage uses the same weighted two-octave field and the
// same conservative partial-derivative bound; a zero scale is the fail-closed result.
constexpr float VF_PassagePerlin2DPartialAbsBound = 8.5f;
constexpr float VF_PassageMaxReliefScale = 0.20f;
static float VF_BuildPassageReliefScale(
const FVector& A, const FVector& B,
float BaseGradient, int32 SegmentIndex, int32 NumSegments,
float Strength, float Frequency)
{
if (!(Strength > 0.0f)
|| !VoxelMath::IsFinite(Strength)
|| !VoxelMath::IsFinite(Frequency)
|| !(FMath::Abs(Frequency) > KINDA_SMALL_NUMBER)
|| !VoxelMath::IsFinite(BaseGradient)
|| BaseGradient < 0.0f)
{
return 0.0f;
}
const float AvailableGradient =
VoxelPassageGeometry::PlayerWalkableFloorMaxGradient - BaseGradient;
if (!(AvailableGradient > 0.0f))
{
return 0.0f;
}
const float Amplitude = FMath::Abs(Strength) * VOXEL_NOISE_SCALE;
const float OctaveFrequencyWeight = 0.65f + 0.35f * 2.3f;
const float NoiseGradientBound =
1.4142135623730951f * VF_PassagePerlin2DPartialAbsBound
* OctaveFrequencyWeight * FMath::Abs(Frequency) * Amplitude;
const int32 LandingEnvelopeCount = (SegmentIndex == 0 ? 1 : 0)
+ (SegmentIndex + 1 == NumSegments ? 1 : 0);
const float HorizontalRun = FVector2D(
static_cast<float>(B.X - A.X),
static_cast<float>(B.Y - A.Y)).Size();
const float EnvelopeDerivativeBound = LandingEnvelopeCount > 0
? (1.5f * static_cast<float>(LandingEnvelopeCount)
/ VoxelPassageGeometry::WalkableTunnelLandingApronVoxels)
* Amplitude
: 0.0f;
const float ReliefGradientBound =
NoiseGradientBound + EnvelopeDerivativeBound;
if (!(ReliefGradientBound > KINDA_SMALL_NUMBER)
|| !VoxelMath::IsFinite(ReliefGradientBound)
|| !(HorizontalRun > KINDA_SMALL_NUMBER))
{
return 0.0f;
}
return FMath::Clamp(
FMath::Min(
VF_PassageMaxReliefScale,
AvailableGradient / ReliefGradientBound),
0.0f, VF_PassageMaxReliefScale);
}
static bool VF_ProjectNativePassageFloorSegment(
const FVoxelPassage& Passage, int32 SegmentIndex,
const FVector& Position, float& OutFloorZ, float& OutSupportRadius,
float& OutDistanceSquared, float& OutHorizontalDistanceSquared,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE)
{
const int32 ControlPointCount = Passage.ControlPoints.Num();
if (!Passage.bNativeFloorEnabled
|| SegmentIndex < 0
|| SegmentIndex + 1 >= ControlPointCount
|| Passage.ControlRadii.Num() != ControlPointCount
|| Passage.NativeFloorProfileZ.Num() != ControlPointCount)
{
return false;
}
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float StartRadius = FMath::Abs(Passage.ControlRadii[SegmentIndex]);
const float EndRadius = FMath::Abs(Passage.ControlRadii[SegmentIndex + 1]);
const double QueryX = static_cast<double>(static_cast<float>(Position.X));
const double QueryY = static_cast<double>(static_cast<float>(Position.Y));
const double AXY_X = static_cast<double>(static_cast<float>(A.X));
const double AXY_Y = static_cast<double>(static_cast<float>(A.Y));
const double DeltaX = static_cast<double>(static_cast<float>(B.X - A.X));
const double DeltaY = static_cast<double>(static_cast<float>(B.Y - A.Y));
const float HorizontalLengthSquared = static_cast<float>(
DeltaX * DeltaX + DeltaY * DeltaY);
if (!(HorizontalLengthSquared > KINDA_SMALL_NUMBER))
{
return false;
}
const double HorizontalDot = (QueryX - AXY_X) * DeltaX
+ (QueryY - AXY_Y) * DeltaY;
const float HorizontalT = FMath::Clamp(
HorizontalDot / HorizontalLengthSquared,
0.0f, 1.0f);
const double HorizontalClosestX = AXY_X + DeltaX * HorizontalT;
const double HorizontalClosestY = AXY_Y + DeltaY * HorizontalT;
const double HorizontalDistanceX = QueryX - HorizontalClosestX;
const double HorizontalDistanceY = QueryY - HorizontalClosestY;
const float HorizontalDistanceSquared = static_cast<float>(
HorizontalDistanceX * HorizontalDistanceX
+ HorizontalDistanceY * HorizontalDistanceY);
OutHorizontalDistanceSquared = HorizontalDistanceSquared;
const float SegmentSupportRadius =
VoxelPassageGeometry::NativePassageFloorSupportRadius(
StartRadius, EndRadius);
if (HorizontalDistanceSquared > FMath::Square(SegmentSupportRadius))
{
return false;
}
const float FloorA = Passage.NativeFloorProfileZ[SegmentIndex];
const float FloorB = Passage.NativeFloorProfileZ[SegmentIndex + 1];
const float FloorDeltaZ = FloorB - FloorA;
const float FullLengthSquared = HorizontalLengthSquared
+ FMath::Square(FloorDeltaZ);
if (!(FullLengthSquared > KINDA_SMALL_NUMBER))
{
return false;
}
const double FullDot = HorizontalDot
+ (static_cast<double>(static_cast<float>(Position.Z)) - FloorA)
* FloorDeltaZ;
const float SpatialT = FMath::Clamp(
FullDot / FullLengthSquared,
0.0f, 1.0f);
const double SpatialX = AXY_X + DeltaX * SpatialT;
const double SpatialY = AXY_Y + DeltaY * SpatialT;
const double SpatialZ = FloorA + FloorDeltaZ * SpatialT;
const double SpatialDistanceX = QueryX - SpatialX;
const double SpatialDistanceY = QueryY - SpatialY;
const double SpatialDistanceZ =
static_cast<double>(static_cast<float>(Position.Z)) - SpatialZ;
OutDistanceSquared = static_cast<float>(
SpatialDistanceX * SpatialDistanceX
+ SpatialDistanceY * SpatialDistanceY
+ SpatialDistanceZ * SpatialDistanceZ);
OutFloorZ = FMath::Lerp(FloorA, FloorB, HorizontalT);
float ReliefScale = 0.0f;
if (Passage.NativeFloorReliefScales.IsValidIndex(SegmentIndex))
{
ReliefScale = Passage.NativeFloorReliefScales[SegmentIndex];
}
float Envelope = 1.0f;
const float HorizontalRun = FMath::Sqrt(HorizontalLengthSquared);
if (SegmentIndex == 0)
{
Envelope *= SmoothStep01(FMath::Clamp(
(HorizontalT * HorizontalRun)
/ VoxelPassageGeometry::WalkableTunnelLandingApronVoxels,
0.0f, 1.0f));
}
if (SegmentIndex + 1 == ControlPointCount - 1)
{
Envelope *= SmoothStep01(FMath::Clamp(
((1.0f - HorizontalT) * HorizontalRun)
/ VoxelPassageGeometry::WalkableTunnelLandingApronVoxels,
0.0f, 1.0f));
}
OutFloorZ += VF_PassageReliefNoise(
Manager, PassageIndex, Passage,
static_cast<double>(Position.X), static_cast<double>(Position.Y))
* VOXEL_NOISE_SCALE * Passage.NativeFloorReliefStrength
* Envelope * ReliefScale;
OutSupportRadius = SegmentSupportRadius;
return VoxelMath::IsFinite(OutFloorZ)
&& VoxelMath::IsFinite(OutSupportRadius)
&& VoxelMath::IsFinite(OutDistanceSquared)
&& OutSupportRadius > 0.0f;
}
// FMath::PerlinNoise2D is in (-1, 1); the two positive octave weights sum to one,
// SmoothStep01 keeps the apron envelope in [0, 1], and each segment stores the scale
// actually consumed by VF_ProjectNativePassageFloorSegment. This is the write supremum,
// including a small float-rounding allowance at the authored floor's world Z.
static bool VF_GetNativePassageFloorReliefBound(
const FVoxelPassage& Passage, float& OutReliefBound)
{
OutReliefBound = 0.0f;
if (!Passage.bNativeFloorEnabled)
{
return true;
}
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num()
|| Passage.NativeFloorProfileZ.Num() != Passage.ControlPoints.Num()
|| Passage.ControlPoints.Num() > 4096)
{
return false;
}
float MaxAbsFloorZ = 0.0f;
for (int32 Index = 0; Index < Passage.ControlPoints.Num(); ++Index)
{
if (!VoxelMath::IsFinite(Passage.NativeFloorProfileZ[Index]))
{
return false;
}
MaxAbsFloorZ = FMath::Max(
MaxAbsFloorZ, FMath::Abs(Passage.NativeFloorProfileZ[Index]));
}
// The relief helper returns exactly zero for these inputs.
if (!(Passage.NativeFloorReliefStrength > 0.0f)
|| !VoxelMath::IsFinite(Passage.NativeFloorReliefStrength)
|| !VoxelMath::IsFinite(Passage.NativeFloorReliefFrequency)
|| !(FMath::Abs(Passage.NativeFloorReliefFrequency) > KINDA_SMALL_NUMBER))
{
return true;
}
float MaxAmplitude = 0.0f;
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const float ReliefScale =
Passage.NativeFloorReliefScales.IsValidIndex(SegmentIndex)
? Passage.NativeFloorReliefScales[SegmentIndex] : 0.0f;
if (!VoxelMath::IsFinite(ReliefScale))
{
return false;
}
const float Amplitude =
FMath::Abs(Passage.NativeFloorReliefStrength)
* VOXEL_NOISE_SCALE * FMath::Abs(ReliefScale);
if (!VoxelMath::IsFinite(Amplitude))
{
return false;
}
MaxAmplitude = FMath::Max(MaxAmplitude, Amplitude);
}
const float RoundingAllowance =
8.0f * FLT_EPSILON * FMath::Max(1.0f, MaxAbsFloorZ + MaxAmplitude)
+ KINDA_SMALL_NUMBER;
OutReliefBound = MaxAmplitude + RoundingAllowance;
return VoxelMath::IsFinite(OutReliefBound);
}
static bool VF_ProjectNativePassageFloorUncached(
const FVoxelPassage& Passage, const FVector& Position,
float& OutFloorZ, float& OutSupportRadius,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE)
{
const int32 SegmentCount = Passage.ControlPoints.Num() - 1;
float BestDistanceSquared = FLT_MAX;
float BestFloorZ = 0.0f;
float BestSupportRadius = 0.0f;
bool bFoundSegment = false;
for (int32 SegmentIndex = 0; SegmentIndex < SegmentCount; ++SegmentIndex)
{
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
float DistanceSquared = FLT_MAX;
float HorizontalDistanceSquared = FLT_MAX;
if (!VF_ProjectNativePassageFloorSegment(
Passage, SegmentIndex, Position,
FloorZ, SupportRadius, DistanceSquared,
HorizontalDistanceSquared,
Manager, PassageIndex)
|| DistanceSquared >= BestDistanceSquared)
{
continue;
}
BestDistanceSquared = DistanceSquared;
BestFloorZ = FloorZ;
BestSupportRadius = SupportRadius;
bFoundSegment = true;
}
if (!bFoundSegment)
{
return false;
}
OutFloorZ = BestFloorZ;
OutSupportRadius = BestSupportRadius;
return true;
}
static bool VF_ProjectNativePassageFloor(
const FVoxelPassage& Passage, const FVector& Position,
float& OutFloorZ, float& OutSupportRadius,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE)
{
FPassageFloorProjectionCacheEntry* Entry =
VF_GetPassageFloorProjectionCacheEntry(Manager, Position, PassageIndex);
if (Entry == nullptr)
{
return VF_ProjectNativePassageFloorUncached(
Passage, Position, OutFloorZ, OutSupportRadius,
Manager, PassageIndex);
}
if (!Entry->Has(FPassageFloorProjectionCacheEntry::NativeComputed))
{
Entry->bNativeValid = VF_ProjectNativePassageFloorUncached(
Passage, Position, Entry->NativeFloorZ,
Entry->NativeSupportRadius, Manager, PassageIndex);
Entry->SetComputed(FPassageFloorProjectionCacheEntry::NativeComputed);
}
if (Entry->bNativeValid)
{
OutFloorZ = Entry->NativeFloorZ;
OutSupportRadius = Entry->NativeSupportRadius;
}
return Entry->bNativeValid;
}
static bool VF_ProjectPassageFloor(
const FVoxelPassage& Passage, const FVector& Position,
float& OutFloorZ, float& OutSupportRadius,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE)
{
FPassageFloorProjectionCacheEntry* Entry =
VF_GetPassageFloorProjectionCacheEntry(Manager, Position, PassageIndex);
if (Entry != nullptr
&& Entry->Has(FPassageFloorProjectionCacheEntry::GenericComputed))
{
if (Entry->bGenericValid)
{
OutFloorZ = Entry->GenericFloorZ;
OutSupportRadius = Entry->GenericSupportRadius;
}
return Entry->bGenericValid;
}
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
bool bValid = VF_ProjectNativePassageFloor(
Passage, Position, FloorZ, SupportRadius,
Manager, PassageIndex);
if (!bValid && Passage.bWalkableTunnelContract)
{
bValid = VoxelPassageGeometry::ProjectWalkableTunnelFloor(
Passage.ControlPoints, Passage.ControlRadii, Position,
FloorZ, SupportRadius);
}
if (Entry != nullptr)
{
Entry->bGenericValid = bValid;
if (bValid)
{
Entry->GenericFloorZ = FloorZ;
Entry->GenericSupportRadius = SupportRadius;
}
Entry->SetComputed(FPassageFloorProjectionCacheEntry::GenericComputed);
}
if (bValid)
{
OutFloorZ = FloorZ;
OutSupportRadius = SupportRadius;
}
return bValid;
}
}
static void VF_AuthorNativePassageFloor(
FVoxelPassage& Passage,
const UVoxelStrateDefinition* UpperDefinition,
const UVoxelStrateDefinition* LowerDefinition,
uint32 PassageSeed)
{
Passage.bNativeFloorEnabled = false;
Passage.NativeFloorProfileZ.Reset();
Passage.NativeFloorReliefScales.Reset();
Passage.NativeFloorReliefStrength = 0.0f;
Passage.NativeFloorReliefFrequency = 0.015f;
Passage.NativeFloorSeed = 0;
if (!Passage.bWalkableTunnelContract
|| Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return;
}
// Inter-strate passages can connect to non-cave archetypes. Keep the native D profile for
// the walkable contract in all cases, but only borrow relief from a cave strate that actually
// owns the same room-floor field. A malformed/unknown parameter source fails closed to a
// flat floor rather than inventing a second relief system.
const FStrateGenerationParams* ReliefParams = nullptr;
if (UpperDefinition != nullptr
&& (UpperDefinition->GeneratorType == ECaveGeneratorType::TunnelNetwork
|| UpperDefinition->GeneratorType == ECaveGeneratorType::Underwater))
{
ReliefParams = &UpperDefinition->GenerationParams;
}
else if (LowerDefinition != nullptr
&& (LowerDefinition->GeneratorType == ECaveGeneratorType::TunnelNetwork
|| LowerDefinition->GeneratorType == ECaveGeneratorType::Underwater))
{
ReliefParams = &LowerDefinition->GenerationParams;
}
if (ReliefParams != nullptr)
{
Passage.NativeFloorReliefStrength = FMath::Max(
ReliefParams->FloorReliefStrength, 0.0f);
Passage.NativeFloorReliefFrequency = ReliefParams->FloorReliefFrequency;
}
Passage.NativeFloorSeed = VoxelHash::Mix(PassageSeed ^ 0xD00DF10Eu);
Passage.NativeFloorProfileZ.SetNum(Passage.ControlPoints.Num());
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num();
++PointIndex)
{
const float Radius = FMath::Abs(Passage.ControlRadii[PointIndex]);
const float FloorZ = VoxelPassageGeometry::TunnelFloorZ(
Passage.ControlPoints[PointIndex], Radius);
if (!VoxelMath::IsFinite(FloorZ))
{
Passage.NativeFloorProfileZ.Reset();
return;
}
Passage.NativeFloorProfileZ[PointIndex] = FloorZ;
}
const int32 NumSegments = Passage.ControlPoints.Num() - 1;
Passage.NativeFloorReliefScales.SetNumZeroed(NumSegments);
for (int32 SegmentIndex = 0;
SegmentIndex < NumSegments;
++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float HorizontalRun = FVector2D(
static_cast<float>(B.X - A.X),
static_cast<float>(B.Y - A.Y)).Size();
const float BaseGradient = HorizontalRun > KINDA_SMALL_NUMBER
? FMath::Abs(
Passage.NativeFloorProfileZ[SegmentIndex + 1]
- Passage.NativeFloorProfileZ[SegmentIndex]) / HorizontalRun
: FLT_MAX;
Passage.NativeFloorReliefScales[SegmentIndex] =
VF_BuildPassageReliefScale(
A, B, BaseGradient, SegmentIndex, NumSegments,
Passage.NativeFloorReliefStrength,
Passage.NativeFloorReliefFrequency);
}
Passage.bNativeFloorEnabled =
Passage.NativeFloorProfileZ.Num() == Passage.ControlPoints.Num();
}
static float VF_BoundarySealThicknessForDefinition(
const UVoxelStrateDefinition& Definition)
{
switch (Definition.GeneratorType)
{
case ECaveGeneratorType::TunnelNetwork:
case ECaveGeneratorType::Underwater:
return Definition.GenerationParams.BoundarySealThickness;
case ECaveGeneratorType::FlatPlain:
case ECaveGeneratorType::CrystalChamber:
return Definition.SlabParams.BoundarySealThickness;
case ECaveGeneratorType::Maze:
return Definition.MazeParams.BoundarySealThickness;
case ECaveGeneratorType::SurfaceWorld:
return Definition.SurfaceParams.BoundarySealThickness;
case ECaveGeneratorType::VerticalShafts:
return Definition.VerticalShaftParams.BoundarySealThickness;
case ECaveGeneratorType::FloatingIslands:
return Definition.FloatingIslandParams.BoundarySealThickness;
default:
return 0.0f;
}
}
/**
* The default inter-strate tunnel is a carved tube plus an explicit support slab. The tube's
* rounded SDF guarantees clearance, but it cannot guarantee a standable surface over a source
* field or a disturbance that was solid before the passage post. Project the query into the
* nearest horizontal control segment and return the conservative floor carried by that segment.
* This is a fixed-size arithmetic loop over the already-built descriptor; it performs no source
* search, allocation, or topology work.
*/
static bool VF_IsWalkableTunnelFloor(
const FVoxelPassage& Passage,
const FVector& Position,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE)
{
if (!Passage.bWalkableTunnelContract
|| Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return false;
}
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
if (!VF_ProjectPassageFloor(
Passage, Position, FloorZ, SupportRadius, Manager, PassageIndex))
{
return false;
}
return Position.Z <= FloorZ + KINDA_SMALL_NUMBER
&& Position.Z > FloorZ - VoxelPassageGeometry::LandingFloorThicknessVoxels;
}
static bool VF_IsWalkableTunnelAir(
const FVoxelPassage& Passage,
const FVector& Position,
const UVoxelStrateManager* Manager = nullptr,
int32 PassageIndex = INDEX_NONE,
float* OutFloorZ = nullptr,
float* OutSupportRadius = nullptr)
{
if (!Passage.bWalkableTunnelContract
|| Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return false;
}
FPassageFloorProjectionCacheEntry* Entry =
VF_GetPassageFloorProjectionCacheEntry(Manager, Position, PassageIndex);
if (Entry != nullptr
&& Entry->Has(FPassageFloorProjectionCacheEntry::WalkableAirComputed))
{
if (Entry->bWalkableAir)
{
if (OutFloorZ != nullptr)
{
*OutFloorZ = Entry->GenericFloorZ;
}
if (OutSupportRadius != nullptr)
{
*OutSupportRadius = Entry->GenericSupportRadius;
}
}
return Entry->bWalkableAir;
}
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
if (!VF_ProjectPassageFloor(
Passage, Position, FloorZ, SupportRadius, Manager, PassageIndex))
{
return false;
}
// The carved tube is wider than this guaranteed core. The core is deliberately expressed as
// a vertical prism over the projected floor: it gives the final-density player stencil a
// stable air volume even when a source archetype or a disturbance would otherwise refill the
// shallow part of the rounded SDF. The floor writer below owns the closed lower face.
const float AirHeight = 2.0f * SupportRadius;
const bool bWalkableAir = Position.Z > FloorZ
+ VoxelPassageGeometry::WalkableTunnelFloorAirClearanceVoxels
&& Position.Z < FloorZ + AirHeight - KINDA_SMALL_NUMBER;
if (Entry != nullptr)
{
Entry->bWalkableAir = bWalkableAir;
Entry->SetComputed(FPassageFloorProjectionCacheEntry::WalkableAirComputed);
}
if (bWalkableAir)
{
if (OutFloorZ != nullptr)
{
*OutFloorZ = FloorZ;
}
if (OutSupportRadius != nullptr)
{
*OutSupportRadius = SupportRadius;
}
}
return bWalkableAir;
}
static bool VF_FindWalkableTunnelAir(
const UVoxelStrateManager* Manager,
const FVector& Position,
int32& OutPassageIndex,
float& OutFloorZ,
float& OutSupportRadius)
{
OutPassageIndex = INDEX_NONE;
OutFloorZ = 0.0f;
OutSupportRadius = 0.0f;
if (Manager == nullptr)
{
return false;
}
const FIntVector ChunkCoord(
FMath::FloorToInt(Position.X / (float)CHUNK_SIZE),
FMath::FloorToInt(Position.Y / (float)CHUNK_SIZE),
FMath::FloorToInt(Position.Z / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(Manager, ChunkCoord);
const TArray<FVoxelPassage>& Passages = Manager->GetPassages();
const FVoxelPassage* PassageData = Passages.GetData();
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex))
{
continue;
}
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (FVector::DistSquared(Position, Passage.BoundCenter) > Passage.BoundRadiusSq
|| !VF_IsWalkableTunnelAir(
Passage, Position, Manager, PassageIndex,
&OutFloorZ, &OutSupportRadius))
{
continue;
}
OutPassageIndex = PassageIndex;
return true;
}
return false;
}
static bool VF_IsAnyPassageFloorAt(
const UVoxelStrateManager* Manager,
const FVector& Position)
{
if (Manager == nullptr)
{
return false;
}
const FIntVector ChunkCoord(
FMath::FloorToInt(Position.X / (float)CHUNK_SIZE),
FMath::FloorToInt(Position.Y / (float)CHUNK_SIZE),
FMath::FloorToInt(Position.Z / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(Manager, ChunkCoord);
const TArray<FVoxelPassage>& Passages = Manager->GetPassages();
const FVoxelPassage* PassageData = Passages.GetData();
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex))
{
continue;
}
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (!VoxelPassageGeometry::VerticalShaftConnectorAirMarker()
&& (VF_IsPassageLandingFloor(Position, Passage.UpperLanding)
|| VF_IsPassageLandingFloor(Position, Passage.LowerLanding)
|| (Manager->ArePassageSupportFloorWritesEnabledForDiagnostics()
&& VF_IsWalkableTunnelFloor(Passage, Position, Manager, PassageIndex))))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
{
VoxelForgeStartupTrace::FStageScope StartupTraceStage(TEXT("StrateManager.Initialize"));
if (!Settings)
{
UE_LOG(LogTemp, Error, TEXT("[StrateManager] No settings provided!"));
return false;
}
FVoxelSeasonManifest SeasonManifest;
bool bUseSeason = false;
if (!Settings->Season.IsNull())
{
UVoxelSeasonAsset* SeasonAsset = Settings->Season.LoadSynchronous();
FString SeasonReport;
if (SeasonAsset == nullptr
|| !SeasonAsset->LoadManifest(SeasonManifest, SeasonReport))
{
UE_LOG(LogTemp, Error,
TEXT("[StrateManager] Season asset is assigned but unusable: %s"),
SeasonAsset ? *SeasonReport : *Settings->Season.ToString());
return false; // Fail closed: falling back to the authored pool would diverge peers.
}
bUseSeason = true;
WorldSeed = SeasonManifest.Seed;
}
// Keep a valid live layout intact until every season/layout validation step below has
// succeeded. RebuildStrates is called from live edit while old meshes are still visible;
// returning false after clearing these members would leave those meshes backed by an empty or
// partial manager. The copies are small (one entry per strate) and this path is not part of
// worker generation.
const TArray<FStrateSlot> PreviousLayout = StrateLayout;
const TArray<FVoxelSeasonStrate> PreviousSeasonStrates = SeasonStrates;
const FString PreviousSeasonContentHash = ActiveSeasonContentHash;
#if WITH_EDITOR
const TMap<int32, TSharedPtr<FVoxelStrateComposerSlotOverride>> PreviousComposerOverrides = ComposerOverrides;
#endif
auto RestorePreviousLayout = [&]()
{
StrateLayout = PreviousLayout;
SeasonStrates = PreviousSeasonStrates;
ActiveSeasonContentHash = PreviousSeasonContentHash;
#if WITH_EDITOR
ComposerOverrides = PreviousComposerOverrides;
#endif
};
StrateLayout.Empty();
SeasonStrates.Empty();
ActiveSeasonContentHash.Reset();
#if WITH_EDITOR
// A full layout rebuild discards any temporary walk-through candidate. The world calls this
// under FScopedGenerationPause, so no worker can observe the map while it is being cleared.
ComposerOverrides.Reset();
#endif
const int32 TotalStrates = bUseSeason
? SeasonManifest.Strates.Num() : Settings->TotalStrates;
const int32 LayoutGapChunks = bUseSeason
? SeasonManifest.InterStrateGapChunks
: FMath::Max(0, Settings->InterStrateGapChunks);
//=========================================================================
// STEP 1: Build shuffled pool (seed-based randomization)
//=========================================================================
// Copy the pool and shuffle it deterministically using the world seed.
// Fixed strates are excluded from the shuffle — they always use their
// assigned definition regardless of seed.
using FLoadedPoolEntry = TPair<FString, UVoxelStrateDefinition*>;
TArray<FLoadedPoolEntry> ShuffledPool;
if (!bUseSeason)
{
for (const TSoftObjectPtr<UVoxelStrateDefinition>& SoftPtr : Settings->StratePool)
{
// Load the asset (synchronous for now — could be async later)
UVoxelStrateDefinition* Def = SoftPtr.LoadSynchronous();
if (Def)
{
ShuffledPool.Emplace(SoftPtr.ToString(), Def);
}
}
}
// Sort by the soft asset path before shuffling. Pointer addresses depend on load order and
// would make the layout machine-dependent. The pool is a set for layout purposes: editor
// reordering must not change the input sequence seen by Fisher-Yates.
// Trier par chemin de soft asset avant le shuffle. Les adresses de pointeurs dépendent de
// l'ordre de chargement et rendraient le layout dépendant de la machine. Le pool est un set
// pour le layout : réordonner l'asset dans l'éditeur ne doit pas changer l'entrée de Fisher-Yates.
ShuffledPool.Sort([](const FLoadedPoolEntry& A, const FLoadedPoolEntry& B)
{
return FCString::Strcmp(*A.Key, *B.Key) < 0;
});
// Seed-based shuffle using Fisher-Yates
// FRandomStream gives us deterministic random numbers from a seed
FRandomStream Rng(WorldSeed);
for (int32 i = ShuffledPool.Num() - 1; i > 0; i--)
{
int32 j = Rng.RandRange(0, i);
ShuffledPool.Swap(i, j);
}
//=========================================================================
// STEP 2: Assign definitions to each strate slot
//=========================================================================
// Walk through strate indices 0..TotalStrates-1.
// Fixed strates use their pinned definition.
// Random strates cycle through the shuffled pool.
int32 PoolCursor = 0; // Current position in the shuffled pool
// Pre-load fixed strate definitions
TMap<int32, UVoxelStrateDefinition*> LoadedFixed;
if (!bUseSeason)
{
for (auto& Pair : Settings->FixedStrates)
{
UVoxelStrateDefinition* Def = Pair.Value.LoadSynchronous();
if (Def)
{
LoadedFixed.Add(Pair.Key, Def);
}
}
}
// Current Z position (in chunks). Starts at 0 and goes downward (negative).
int32 CurrentTopZ = 0;
for (int32 i = 0; i < TotalStrates; i++)
{
FStrateSlot Slot;
Slot.StrateIndex = i;
if (bUseSeason)
{
const FVoxelSeasonStrate& SeasonStrate = SeasonManifest.Strates[i];
if (!SeasonStrate.SourceDefinitionPath.IsEmpty())
{
TSoftObjectPtr<UVoxelStrateDefinition> SourceDefinition(
FSoftObjectPath(SeasonStrate.SourceDefinitionPath));
UVoxelStrateDefinition* LoadedDefinition = SourceDefinition.LoadSynchronous();
if (LoadedDefinition == nullptr)
{
UE_LOG(LogTemp, Error,
TEXT("[StrateManager] Season slot %d could not load authored definition '%s'."),
i, *SeasonStrate.SourceDefinitionPath);
RestorePreviousLayout();
return false;
}
// Keep the authored content/passage/visual bag without mutating the cooked asset,
// then make the manifest's density identity authoritative below.
Slot.Definition = DuplicateObject<UVoxelStrateDefinition>(LoadedDefinition, this);
}
else
{
// The current density manifest has no wider content record. Keep all consumers
// supplied with a stable definition object, but do not guess an authored theme.
Slot.Definition = NewObject<UVoxelStrateDefinition>(this, NAME_None, RF_Transient);
Slot.Definition->StrateName = FText::FromString(
FString::Printf(TEXT("Season %d Strate %d"), SeasonManifest.Season, i));
Slot.Definition->TransitionType = EVoxelStrateTransition::Hard;
// Passage configuration is not part of schema v2. Inventing the UObject default
// here would add an unreviewed tunnel to every generated boundary and make the
// runtime field differ from the field that passed composition. The origin spine
// remains the guaranteed connection until a later schema explicitly stores these.
Slot.Definition->PassageConfig.Connections = 0;
}
Slot.Definition->GeneratorType = SeasonStrate.Archetype;
Slot.Definition->bUseOperatorStack = SeasonStrate.bUsesRecipe;
Slot.Definition->StrateHeightInChunks = SeasonStrate.HeightInChunks;
Slot.Definition->GenerationParams = SeasonStrate.Params.TunnelNetworkParams;
Slot.Definition->SlabParams = SeasonStrate.Params.SlabParams;
Slot.Definition->MazeParams = SeasonStrate.Params.MazeParams;
Slot.Definition->SurfaceParams = SeasonStrate.Params.SurfaceParams;
Slot.Definition->VerticalShaftParams = SeasonStrate.Params.VerticalShaftParams;
Slot.Definition->FloatingIslandParams = SeasonStrate.Params.FloatingIslandParams;
Slot.HeightInChunks = SeasonStrate.HeightInChunks;
Slot.TopChunkZ = SeasonStrate.TopWorldZ / CHUNK_SIZE - 1;
Slot.BottomChunkZ = SeasonStrate.BottomWorldZ / CHUNK_SIZE;
if (SeasonStrate.TopWorldZ % CHUNK_SIZE != 0
|| SeasonStrate.BottomWorldZ % CHUNK_SIZE != 0
|| Slot.TopChunkZ != CurrentTopZ
|| Slot.BottomChunkZ != CurrentTopZ - (Slot.HeightInChunks - 1))
{
UE_LOG(LogTemp, Error,
TEXT("[StrateManager] Season slot %d bounds do not describe the declared stacked layout."), i);
RestorePreviousLayout();
return false;
}
SeasonStrates.Add(SeasonStrate);
}
else
{
// Pick definition: fixed or from pool
UVoxelStrateDefinition** FixedDef = LoadedFixed.Find(i);
if (FixedDef && *FixedDef)
{
Slot.Definition = *FixedDef;
}
else if (ShuffledPool.Num() > 0)
{
// Cycle through the pool (wraps around if more strates than pool entries)
Slot.Definition = ShuffledPool[PoolCursor % ShuffledPool.Num()].Value;
PoolCursor++;
}
else
{
UE_LOG(LogTemp, Warning, TEXT("[StrateManager] No strate definitions available for slot %d!"), i);
continue;
}
// Compute Z range from definition's height
Slot.HeightInChunks = Slot.Definition->StrateHeightInChunks;
Slot.TopChunkZ = CurrentTopZ;
Slot.BottomChunkZ = CurrentTopZ - (Slot.HeightInChunks - 1);
}
// Move the cursor down for the next strate, leaving a solid-bedrock gap of
// InterStrateGapChunks chunks between this strate and the next.
CurrentTopZ = Slot.BottomChunkZ - 1 - LayoutGapChunks;
StrateLayout.Add(Slot);
if (VoxelForgeStartupTrace::IsActive())
{
FString DefinitionPath = Slot.Definition ? Slot.Definition->GetPathName() : FString();
DefinitionPath.ReplaceInline(TEXT("\\"), TEXT("\\\\"));
DefinitionPath.ReplaceInline(TEXT("\""), TEXT("\\\""));
const UEnum* ArchetypeEnum = StaticEnum<ECaveGeneratorType>();
const FString ArchetypeName = ArchetypeEnum
? ArchetypeEnum->GetNameStringByValue(static_cast<int64>(Slot.Definition->GeneratorType))
: FString::Printf(TEXT("Value_%d"), static_cast<int32>(Slot.Definition->GeneratorType));
VoxelForgeStartupTrace::RecordEvent(TEXT("strate_slot"), FString::Printf(
TEXT("\"index\":%d,\"definition\":\"%s\",\"archetype\":\"%s\",\"top_chunk_z\":%d,"
"\"bottom_chunk_z\":%d,\"height_chunks\":%d,\"operator_stack\":%d"),
Slot.StrateIndex, *DefinitionPath, *ArchetypeName,
Slot.TopChunkZ, Slot.BottomChunkZ, Slot.HeightInChunks,
Slot.Definition->bUseOperatorStack ? 1 : 0));
}
UE_LOG(LogTemp, Log, TEXT("[StrateManager] Strate %d: '%s' | Z chunks [%d to %d] | %d chunks tall"),
i,
*Slot.Definition->StrateName.ToString(),
Slot.TopChunkZ,
Slot.BottomChunkZ,
Slot.HeightInChunks);
}
// Diagnostic de configuration, une seule fois par construction de layout. SurfaceWorld est
// volontairement exclu : son chemin T1.d exact-lattice ne dépend pas de ce drapeau.
// Configuration diagnostic once per layout build. SurfaceWorld is deliberately excluded:
// its exact-lattice T1.d path does not depend on this flag.
int32 NumCaveSlots = 0;
int32 NumOperatorStackDisabledCaves = 0;
for (const FStrateSlot& Slot : StrateLayout)
{
const ECaveGeneratorType SlotArchetype = bUseSeason
? SeasonStrates[Slot.StrateIndex].Archetype : Slot.Definition->GeneratorType;
if (!Slot.Definition || SlotArchetype == ECaveGeneratorType::SurfaceWorld)
{
continue;
}
++NumCaveSlots;
const bool bUsesStack = bUseSeason
? SeasonStrates[Slot.StrateIndex].bUsesRecipe : Slot.Definition->bUseOperatorStack;
if (!bUsesStack)
{
++NumOperatorStackDisabledCaves;
}
}
// ⚠️ WARNING EN ÉDITEUR/JEU, JAMAIS EN TEST. Les tests `Determinism.*` construisent
// DÉLIBÉRÉMENT un monde non opt-in — c'est leur oracle de comparaison — et le framework
// d'automatisation compte un Warning comme un échec. Un diagnostic ne doit pas casser la suite
// qu'il est censé éclairer. Le message reste écrit UNE fois : seule la verbosité change.
// Warning in editor/game where it is actionable, never in tests: the Determinism.* tests build
// a non-opted-in world ON PURPOSE as their comparison oracle, and the automation framework
// treats a Warning as a failure. One message, two verbosities.
const bool bQuietDiagnostic = GIsAutomationTesting;
if (NumOperatorStackDisabledCaves > 0)
{
const FString Summary = FString::Printf(
TEXT("[StrateManager] Operator-stack opt-in: %d/%d cave layout slots have Use Operator Stack disabled. These slots cannot use operator-stack ClassifyBox/T1.d; enable the asset setting on the listed definitions if that is intended."),
NumOperatorStackDisabledCaves, NumCaveSlots);
if (bQuietDiagnostic) { UE_LOG(LogTemp, Verbose, TEXT("%s"), *Summary); }
else { UE_LOG(LogTemp, Warning, TEXT("%s"), *Summary); }
}
else
{
UE_LOG(LogTemp, Log,
TEXT("[StrateManager] Operator-stack opt-in: all %d cave layout slots have Use Operator Stack enabled."),
NumCaveSlots);
}
for (const FStrateSlot& Slot : StrateLayout)
{
const bool bSeasonStack = bUseSeason
&& SeasonStrates[Slot.StrateIndex].bUsesRecipe;
const ECaveGeneratorType SlotArchetype = bUseSeason
? SeasonStrates[Slot.StrateIndex].Archetype : Slot.Definition->GeneratorType;
if (!Slot.Definition
|| SlotArchetype == ECaveGeneratorType::SurfaceWorld
|| (bUseSeason ? bSeasonStack : Slot.Definition->bUseOperatorStack))
{
continue;
}
const FString Line = FString::Printf(
TEXT("[StrateManager] cave slot=%d name='%s' Z chunks=[%d to %d] bUseOperatorStack=false"),
Slot.StrateIndex,
*Slot.Definition->StrateName.ToString(),
Slot.TopChunkZ,
Slot.BottomChunkZ);
if (bQuietDiagnostic) { UE_LOG(LogTemp, Verbose, TEXT("%s"), *Line); }
else { UE_LOG(LogTemp, Warning, TEXT("%s"), *Line); }
}
CachedSeed = WorldSeed;
bOpenSurfaceEntry = Settings->bOpenSurfaceEntry;
OriginSpineRadius = bUseSeason
? SeasonManifest.OriginSpineRadius : Settings->OriginSpineRadius;
InterStrateGapChunks = LayoutGapChunks;
if (bUseSeason)
{
ActiveSeasonContentHash = SeasonManifest.ContentHash;
}
// Passage shape/count is per-strate now (UVoxelStrateDefinition::PassageConfig).
//=========================================================================
// STEP 3: Load terrain operation assets
//=========================================================================
// Each strate definition references terrain ops as soft pointers.
// We load them synchronously here so they're available during generation.
// Without this, BuildParamsFromDefinition's Entry.Operation.Get() would
// return null if the assets haven't been loaded yet.
for (const FStrateSlot& Slot : StrateLayout)
{
if (!Slot.Definition) continue;
if (bUseSeason && SeasonStrates[Slot.StrateIndex].bUsesRecipe) continue;
for (const FStrateTerrainOpEntry& Entry : Slot.Definition->TerrainOperations)
{
if (!Entry.Operation.IsNull())
{
Entry.Operation.LoadSynchronous();
}
}
}
UE_LOG(LogTemp, Log, TEXT("[StrateManager] Initialized %d strates (seed=%d)"),
StrateLayout.Num(), WorldSeed);
VoxelForgeStartupTrace::RecordEvent(TEXT("strate_layout_ready"), FString::Printf(
TEXT("\"strates\":%d,\"seed\":%d,\"inter_strate_gap_chunks\":%d,\"season\":%d"),
StrateLayout.Num(), WorldSeed, InterStrateGapChunks, bUseSeason ? 1 : 0));
// Generate passages between consecutive strates
GeneratePassages();
return bUseSeason ? IsUsingSeason() : true;
}
#if WITH_EDITOR
const FVoxelStrateComposerSlotOverride* UVoxelStrateManager::FindComposerOverride(
int32 StrateIndex) const
{
const TSharedPtr<FVoxelStrateComposerSlotOverride>* Found = ComposerOverrides.Find(StrateIndex);
return Found != nullptr ? Found->Get() : nullptr;
}
bool UVoxelStrateManager::SetComposerOverrideForStrate(
int32 StrateIndex, int32 CandidateSeed, ECaveGeneratorType Archetype,
const FVoxelStrateArchetypeParams& Params, bool bUseRecipe,
const FVoxelOpStackRecipe* Recipe, FString& OutError,
const FVoxelStrateRegionManifest* InRegions)
{
OutError.Reset();
const FStrateSlot* TargetSlot = nullptr;
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.StrateIndex == StrateIndex)
{
TargetSlot = &Slot;
break;
}
}
if (TargetSlot == nullptr || TargetSlot->Definition == nullptr)
{
OutError = FString::Printf(TEXT("Strate index %d is not present in the live layout."), StrateIndex);
return false;
}
switch (Archetype)
{
case ECaveGeneratorType::TunnelNetwork:
case ECaveGeneratorType::FlatPlain:
case ECaveGeneratorType::CrystalChamber:
case ECaveGeneratorType::Maze:
case ECaveGeneratorType::SurfaceWorld:
case ECaveGeneratorType::VerticalShafts:
case ECaveGeneratorType::FloatingIslands:
case ECaveGeneratorType::Underwater:
break;
default:
OutError = TEXT("The composer returned an unsupported strate archetype.");
return false;
}
if (bUseRecipe && Recipe == nullptr)
{
OutError = TEXT("A structure candidate did not provide a recipe.");
return false;
}
TSharedPtr<FVoxelStrateComposerSlotOverride> Override =
MakeShared<FVoxelStrateComposerSlotOverride>();
Override->CandidateSeed = CandidateSeed;
Override->Archetype = Archetype;
Override->Params = Params;
if ((VF_WormsForceOff() || !TargetSlot->Definition->bEnableWorms)
&& (Archetype == ECaveGeneratorType::TunnelNetwork
|| Archetype == ECaveGeneratorType::Underwater))
{
// The composer is allowed to roll a complete candidate, but a disabled asset must never
// retain a worm-enabled candidate in its runtime override, even for code that inspects
// the override before GetGenerationParams applies the final resolution gate.
Override->Params.TunnelNetworkParams.WormStrength = 0.0f;
}
VF_SetComposerRuntimeBounds(
Override->Params,
(float)(TargetSlot->TopChunkZ + 1) * CHUNK_SIZE,
(float)TargetSlot->BottomChunkZ * CHUNK_SIZE);
Override->bUseRecipe = bUseRecipe;
if (Recipe != nullptr)
{
Override->Recipe = *Recipe;
}
if (InRegions != nullptr && InRegions->RegionCount > 1)
{
if (!InRegions->IsValid())
{
OutError = InRegions->FailureReason.IsEmpty()
? TEXT("The composer returned an invalid lateral region manifest.")
: InRegions->FailureReason;
return false;
}
Override->bUseRegions = true;
Override->Regions = *InRegions;
VF_RekeyStrateRegionManifest(Override->Regions, CandidateSeed, StrateIndex);
Override->Regions.StrateTopWorldZ = (float)(TargetSlot->TopChunkZ + 1) * CHUNK_SIZE;
Override->Regions.StrateBottomWorldZ = (float)TargetSlot->BottomChunkZ * CHUNK_SIZE;
VF_SetStrateArchetypeRuntimeBounds(Override->Params,
Override->Regions.StrateTopWorldZ,
Override->Regions.StrateBottomWorldZ);
for (FVoxelStrateRegion& Region : Override->Regions.Regions)
{
VF_SetStrateArchetypeRuntimeBounds(Region.ArchetypeParams,
Override->Regions.StrateTopWorldZ,
Override->Regions.StrateBottomWorldZ);
}
Override->Regions.bHasGlobalStructuralParams = true;
}
// Only one slot is overridden at a time. Keeping this map small also makes the worker-side
// copy-on-chunk-refetch cheap. Passage geometry is deliberately not regenerated: the layout
// and its passages are unchanged, and this is the same manager state used by the offline
// candidate measurement harness.
ComposerOverrides.Reset();
ComposerOverrides.Add(StrateIndex, MoveTemp(Override));
// This is both the passage-shortlist invalidation counter and the cache key used by the
// generator's per-chunk params/stack memos. The world has already paused all readers.
++PassagesVersion;
return true;
}
bool UVoxelStrateManager::GetComposerOverrideForChunk(
const FIntVector& ChunkCoord, int32& OutCandidateSeed,
ECaveGeneratorType& OutArchetype, FVoxelStrateArchetypeParams& OutParams,
bool& bOutUseRecipe, FVoxelOpStackRecipe& OutRecipe) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0)
{
return false;
}
const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(StrateLayout[SlotIdx].StrateIndex);
if (Override == nullptr)
{
return false;
}
OutCandidateSeed = Override->CandidateSeed;
OutArchetype = Override->Archetype;
OutParams = Override->Params;
bOutUseRecipe = Override->bUseRecipe;
OutRecipe = Override->Recipe;
return true;
}
bool UVoxelStrateManager::GetComposerRegionOverrideForChunk(
const FIntVector& ChunkCoord, FVoxelStrateRegionManifest& OutRegions) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0)
{
return false;
}
const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(StrateLayout[SlotIdx].StrateIndex);
if (Override == nullptr || !Override->bUseRegions)
{
return false;
}
OutRegions = Override->Regions;
return true;
}
#endif
bool UVoxelStrateManager::GetRecipeForChunk(
const FIntVector& ChunkCoord, int32& OutRecipeSeed,
ECaveGeneratorType& OutArchetype, FVoxelStrateArchetypeParams& OutParams,
FVoxelOpStackRecipe& OutRecipe) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0) return false;
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(StrateLayout[SlotIdx].StrateIndex))
{
if (!Override->bUseRecipe || Override->bUseRegions) return false;
OutRecipeSeed = Override->CandidateSeed;
OutArchetype = Override->Archetype;
OutParams = Override->Params;
OutRecipe = Override->Recipe;
return true;
}
#endif
if (SeasonStrates.IsValidIndex(SlotIdx))
{
const FVoxelSeasonStrate& Strate = SeasonStrates[SlotIdx];
if (!Strate.bUsesRecipe || Strate.bUsesRegions) return false;
OutRecipeSeed = Strate.Seed;
OutArchetype = Strate.Archetype;
OutParams = Strate.Params;
OutRecipe = Strate.Recipe;
return true;
}
return false;
}
//=============================================================================
// PASSAGE GENERATION
//=============================================================================
void UVoxelStrateManager::GeneratePassages()
{
VoxelForgeStartupTrace::FStageScope StartupTraceStage(TEXT("GeneratePassages"));
// Invalidate worker-local passage shortlists even when the new layout is empty. Returning
// before this bump would leave a nearby-passage TLS list pointing at the cleared array.
++PassagesVersion;
Passages.Empty();
if (StrateLayout.Num() < 1)
{
VoxelForgeStartupTrace::RecordEvent(TEXT("passages_ready"), TEXT("\"passages\":0"));
return;
}
// Deterministic per-value hashes from the world seed. Every draw is keyed by its boundary
// strate index, connection index, and a unique salt, so one passage cannot shift another.
// Hachages déterministes par valeur depuis le seed du monde. Chaque tirage est indexé par la
// strate de frontière, la connexion et un sel unique : un passage ne peut plus décaler l'autre.
const uint32 PassageSeed = static_cast<uint32>(CachedSeed) ^ 0x50A55A6Eu; // "PASSAGE"
constexpr uint32 PassageSaltAngle = 0xA1100001u;
constexpr uint32 PassageSaltDistance = 0xA1100002u;
constexpr uint32 PassageSaltUpperReach = 0xA1100003u;
constexpr uint32 PassageSaltLowerReach = 0xA1100004u;
constexpr uint32 PassageSaltWormFreq = 0xA1100005u;
constexpr uint32 PassageSaltNoiseX = 0xA1100006u;
constexpr uint32 PassageSaltNoiseY = 0xA1100007u;
constexpr uint32 PassageSaltNoiseZ = 0xA1100008u;
constexpr uint32 PassageSaltPhase = 0xA1100009u;
constexpr uint32 PassageSaltBendFreq = 0xA110000Au;
constexpr uint32 PassageSaltUpperDoor = 0xA110000Bu;
constexpr uint32 PassageSaltLowerDoor = 0xA110000Cu;
int32 TotalPassages = 0;
int32 NumAimedAtUpperPlayerFit = 0;
int32 NumAimedAtLowerPlayerFit = 0;
TSet<FString> NoQueryArchetypes;
const auto ArchetypeName = [](ECaveGeneratorType Archetype)
{
if (const UEnum* ArchetypeEnum = StaticEnum<ECaveGeneratorType>())
{
return ArchetypeEnum->GetNameStringByValue(static_cast<int64>(Archetype));
}
return FString::Printf(TEXT("Value_%d"), static_cast<int32>(Archetype));
};
const auto MaxLateralSnapFor = [](const UVoxelStrateDefinition& Definition) -> float
{
switch (Definition.GeneratorType)
{
case ECaveGeneratorType::Maze:
// One maze lattice cell is the largest deliberate correction. It keeps a shortcut
// within the same local maze neighborhood and protects its configured spine-distance
// distribution from silently becoming a long-range teleport.
return FMath::Max(Definition.MazeParams.CellSize, 1.0f);
case ECaveGeneratorType::VerticalShafts:
// A density of 0.6 does not guarantee an occupied cell in the immediate grid
// neighbourhood. Allow the nearest occupied shaft to be two grid cells away while
// remaining a bounded local query; the landing query still returns a pose inside
// that shaft's deterministic feature core, so this cannot create a non-topological
// mouth.
return FMath::Max(2.0f * Definition.VerticalShaftParams.ShaftSpacing, 1.0f);
case ECaveGeneratorType::FloatingIslands:
// One island grid spacing protects the intentional radial placement while still
// allowing a passage to reach a neighboring blob rather than an arbitrary far island.
return FMath::Max(Definition.FloatingIslandParams.IslandSpacing, 1.0f);
case ECaveGeneratorType::TunnelNetwork:
case ECaveGeneratorType::Underwater:
// Une salle est une CIBLE ÉPARSE en XY, exactement comme un couloir de labyrinthe : le
// budget doit donc être réel. Zéro ici est un bug — la requête trouve la salle la plus
// proche puis atterrit à côté d'elle dans 92,8 % des cas (balayage d'un million de
// seeds). Un espacement de salles est le voisinage local naturel.
//
// A room is an XY-SPARSE target, exactly like a maze corridor, so the budget must be
// real. Zero here is a bug: the query finds the nearest room and then lands beside it
// 92.8% of the time (million-seed sweep). One room spacing is the natural local
// neighbourhood, and it protects the configured spine-distance distribution.
return FMath::Max(Definition.GenerationParams.RoomSpacing, 1.0f);
case ECaveGeneratorType::FlatPlain:
case ECaveGeneratorType::CrystalChamber:
default:
// Les slabs sont une bande de vide CONTINUE en XY : le XY demandé est déjà à
// l'intérieur, donc aucun déplacement latéral n'est nécessaire. Zéro est correct ici.
// A slab's void band is XY-CONTINUOUS, so the requested XY is already inside it and no
// lateral movement is needed. Zero is correct here, unlike for rooms.
return 0.0f;
}
};
const auto BoundarySealThicknessFor = [](const UVoxelStrateDefinition& Definition) -> float
{
switch (Definition.GeneratorType)
{
case ECaveGeneratorType::TunnelNetwork:
case ECaveGeneratorType::Underwater:
return Definition.GenerationParams.BoundarySealThickness;
case ECaveGeneratorType::FlatPlain:
case ECaveGeneratorType::CrystalChamber:
return Definition.SlabParams.BoundarySealThickness;
case ECaveGeneratorType::Maze:
return Definition.MazeParams.BoundarySealThickness;
case ECaveGeneratorType::SurfaceWorld:
return Definition.SurfaceParams.BoundarySealThickness;
case ECaveGeneratorType::VerticalShafts:
return Definition.VerticalShaftParams.BoundarySealThickness;
case ECaveGeneratorType::FloatingIslands:
return Definition.FloatingIslandParams.BoundarySealThickness;
default:
return 0.0f;
}
};
//=========================================================================
// INTER-STRATE PASSAGES: tunnels connecting consecutive strates.
// Each passage is randomly assigned one of 5 types, which determines
// its shape, radius, and control point layout.
//=========================================================================
for (int32 i = 0; i < StrateLayout.Num() - 1; i++)
{
const FStrateSlot& Upper = StrateLayout[i];
const FStrateSlot& Lower = StrateLayout[i + 1];
// This (upper) strate's PassageConfig controls the progression tunnel to the layer below.
// Each strate already owns a finite (0,0) landing room; this passage is the connection
// that opens the next room rather than a second vertical spine.
const UVoxelStrateDefinition* UpperDef = Upper.Definition;
if (!UpperDef) continue;
const FStratePassageConfig& Cfg = UpperDef->PassageConfig;
// Upper strate floor and lower strate ceiling (differ when there's a bedrock gap).
const float UpperTopZ = (float)(Upper.TopChunkZ + 1) * CHUNK_SIZE;
const float UpperBottomZ = (float)(Upper.BottomChunkZ) * CHUNK_SIZE;
const float LowerTopZ = (float)(Lower.TopChunkZ + 1) * CHUNK_SIZE;
const float UpperMax = (float)Upper.HeightInChunks * CHUNK_SIZE * 0.9f;
const float LowerMax = (float)Lower.HeightInChunks * CHUNK_SIZE * 0.9f;
const float DistLo = FMath::Min(Cfg.DistanceMin, Cfg.DistanceMax);
const float DistHi = FMath::Max(Cfg.DistanceMin, Cfg.DistanceMax);
// The origin room owns the future straight shaft. Keep the progression mouth outside its
// carve/blend envelope, then choose a deterministic point in the authored annulus. If an
// asset has an invalid inner radius, repair only that radius; the outer authored radius is
// preserved unless it is too small to contain the required inner edge.
const float OriginLandingHalfWidth =
VoxelPassageGeometry::LandingHalfWidthForRadius(OriginSpineRadius);
const float MinimumDescentDistance = FMath::Max(
OriginLandingHalfWidth + VoxelPassageGeometry::LandingCarveBlendVoxels,
VoxelPassageGeometry::MinimumTurnFloorWidthVoxels);
const float PlacementLo = FMath::Max(DistLo, MinimumDescentDistance);
const float PlacementHi = FMath::Max(DistHi, PlacementLo);
const int32 Conns = FMath::Max(0, Cfg.Connections);
for (int32 c = 0; c < Conns; c++)
{
const auto PassageRandom01 = [PassageSeed, i, c](uint32 Salt)
{
return VoxelHash::ToFloat01(VoxelHash::Cell(i, c, PassageSeed ^ Salt));
};
const auto PassageRandomRange = [&PassageRandom01](float Min, float Max, uint32 Salt)
{
return FMath::Lerp(Min, Max, PassageRandom01(Salt));
};
FVoxelPassage Passage;
Passage.UpperStrateIndex = i;
Passage.LowerStrateIndex = i + 1;
// The authored style is also reflected in the legacy passage type. In particular,
// only Straight receives the walkable-tunnel contract; a future style roll cannot
// silently inherit the default's player-fit promise.
switch (Cfg.Style)
{
case EVoxelPassageStyle::Straight:
Passage.PassageType = EVoxelPassageType::SlopedTunnel;
break;
case EVoxelPassageStyle::Spiral:
Passage.PassageType = EVoxelPassageType::SpiralDescent;
break;
case EVoxelPassageStyle::Cascading:
Passage.PassageType = EVoxelPassageType::CascadingDrops;
break;
case EVoxelPassageStyle::Worm:
default:
Passage.PassageType = EVoxelPassageType::CrackCrevice;
break;
}
// PLACEMENT: random angle, distance from the (0,0) spine within a deterministic
// annulus. It is deliberately not the spine: that room is reserved for the future
// surface shaft, while this passage opens a separate room in the strate network.
const float Angle = PassageRandom01(PassageSaltAngle) * (2.0f * PI);
const float Distance = PassageRandomRange(PlacementLo, PlacementHi, PassageSaltDistance);
float SinAngle = 0.0f, CosAngle = 0.0f;
VoxelMath::DetSinCos(SinAngle, CosAngle, Angle);
const float PX = CosAngle * Distance;
const float PY = SinAngle * Distance;
++TotalPassages;
// Ask each mouth's own strate for a source-level landing point. These queries are pure
// and safe during Initialize: they do not construct an operator stack or call back
// into the manager. Cave room graphs use the queried strate's seed from
// MakeStrateSeed; slab, maze, shaft, and island fields use the world seed consumed by
// their source. The two queries are deliberately independent: a passage never reads
// another passage's endpoint or any live layout state.
FVector SuggestedUpperPoint = FVector::ZeroVector;
bool bAimedUpperAtPlayerFitPoint = false;
if (UpperDef)
{
const bool bUsesRoomSeed =
UpperDef->GeneratorType == ECaveGeneratorType::TunnelNetwork
|| UpperDef->GeneratorType == ECaveGeneratorType::Underwater;
const int32 UpperQuerySeed = bUsesRoomSeed
? static_cast<int32>(VoxelCaveMorphology::MakeStrateSeed(
static_cast<uint32>(CachedSeed), Upper.StrateIndex))
: CachedSeed;
bAimedUpperAtPlayerFitPoint = VF_SuggestLandingPoint(
UpperDef->GeneratorType,
UpperDef->GenerationParams,
UpperDef->SlabParams,
UpperDef->MazeParams,
UpperDef->VerticalShaftParams,
UpperDef->FloatingIslandParams,
UpperQuerySeed,
UpperTopZ,
UpperBottomZ,
PX,
PY,
MaxLateralSnapFor(*UpperDef),
SuggestedUpperPoint,
CachedSeed);
if (bAimedUpperAtPlayerFitPoint)
{
++NumAimedAtUpperPlayerFit;
}
else
{
NoQueryArchetypes.Add(ArchetypeName(UpperDef->GeneratorType));
}
}
FVector SuggestedLowerPoint = FVector::ZeroVector;
bool bAimedLowerAtPlayerFitPoint = false;
const UVoxelStrateDefinition* LowerDef = Lower.Definition;
if (LowerDef)
{
const bool bUsesRoomSeed =
LowerDef->GeneratorType == ECaveGeneratorType::TunnelNetwork
|| LowerDef->GeneratorType == ECaveGeneratorType::Underwater;
const int32 LowerQuerySeed = bUsesRoomSeed
? static_cast<int32>(VoxelCaveMorphology::MakeStrateSeed(
static_cast<uint32>(CachedSeed), Lower.StrateIndex))
: CachedSeed;
const float MaxLateralSnap = MaxLateralSnapFor(*LowerDef);
bAimedLowerAtPlayerFitPoint = VF_SuggestLandingPoint(
LowerDef->GeneratorType,
LowerDef->GenerationParams,
LowerDef->SlabParams,
LowerDef->MazeParams,
LowerDef->VerticalShaftParams,
LowerDef->FloatingIslandParams,
LowerQuerySeed,
LowerTopZ,
(float)(Lower.BottomChunkZ) * CHUNK_SIZE,
PX,
PY,
MaxLateralSnap,
SuggestedLowerPoint,
CachedSeed);
if (bAimedLowerAtPlayerFitPoint)
{
++NumAimedAtLowerPlayerFit;
}
else
{
NoQueryArchetypes.Add(ArchetypeName(LowerDef->GeneratorType));
}
}
// LENGTH: reach into each strate, capped to the interior.
const float UpperReach = FMath::Min(
PassageRandomRange(Cfg.ReachMin, Cfg.ReachMax, PassageSaltUpperReach), UpperMax);
const float LowerReach = FMath::Min(
PassageRandomRange(Cfg.ReachMin, Cfg.ReachMax, PassageSaltLowerReach), LowerMax);
float TopZ = UpperBottomZ + UpperReach;
float BottomZ = LowerTopZ - LowerReach;
float UpperX = PX;
float UpperY = PY;
float LowerX = PX;
float LowerY = PY;
Passage.RequestedUpperPoint = FVector(PX, PY, TopZ);
Passage.RequestedLowerPoint = FVector(PX, PY, BottomZ);
if (bAimedUpperAtPlayerFitPoint)
{
const float UpperSealThickness = BoundarySealThicknessFor(*UpperDef);
const float InnerBottomZ = UpperBottomZ + UpperSealThickness;
const float InnerTopZ = UpperTopZ - UpperSealThickness;
if (VoxelMath::IsFinite(SuggestedUpperPoint.X)
&& VoxelMath::IsFinite(SuggestedUpperPoint.Y)
&& VoxelMath::IsFinite(SuggestedUpperPoint.Z)
&& VoxelMath::IsFinite(InnerBottomZ)
&& VoxelMath::IsFinite(InnerTopZ)
&& InnerBottomZ < InnerTopZ)
{
// VF_SuggestLandingPoint already guarantees a strict interior answer. Keep a
// tiny margin in the final clamp so a future source query cannot land on a
// seal boundary through rounding.
UpperX = SuggestedUpperPoint.X;
UpperY = SuggestedUpperPoint.Y;
const float StrictMargin = FMath::Min(
KINDA_SMALL_NUMBER, (InnerTopZ - InnerBottomZ) * 0.25f);
TopZ = FMath::Clamp(
SuggestedUpperPoint.Z,
InnerBottomZ + StrictMargin,
InnerTopZ - StrictMargin);
}
}
if (bAimedLowerAtPlayerFitPoint)
{
const float LowerSealThickness = BoundarySealThicknessFor(*LowerDef);
const float LowerBottomZ = (float)(Lower.BottomChunkZ) * CHUNK_SIZE;
const float InnerBottomZ = LowerBottomZ + LowerSealThickness;
const float InnerTopZ = LowerTopZ - LowerSealThickness;
if (VoxelMath::IsFinite(SuggestedLowerPoint.X)
&& VoxelMath::IsFinite(SuggestedLowerPoint.Y)
&& VoxelMath::IsFinite(SuggestedLowerPoint.Z)
&& VoxelMath::IsFinite(InnerBottomZ)
&& VoxelMath::IsFinite(InnerTopZ)
&& InnerBottomZ < InnerTopZ)
{
// VF_SuggestLandingPoint already guarantees a strict interior answer. Keep a
// tiny margin in the final clamp so a future source query cannot land on a
// seal boundary through rounding.
LowerX = SuggestedLowerPoint.X;
LowerY = SuggestedLowerPoint.Y;
const float StrictMargin = FMath::Min(
KINDA_SMALL_NUMBER, (InnerTopZ - InnerBottomZ) * 0.25f);
BottomZ = FMath::Clamp(
SuggestedLowerPoint.Z,
InnerBottomZ + StrictMargin,
InnerTopZ - StrictMargin);
}
}
const int32 Segments = FMath::Clamp(Cfg.Segments, 1, 48);
Passage.ControlPoints.Reset();
Passage.ControlRadii.Reset();
Passage.ControlPoints.Reserve(Segments + 1);
Passage.ControlRadii.Reserve(Segments + 1);
// WIDTH profile: mouth radius at the ends, mid radius in the centre (taper/bulge).
auto RadiusAt = [&](float t) { return FMath::Lerp(Cfg.MouthRadius, Cfg.MidRadius, VoxelMath::DetSin(t * PI)); };
// Per-passage shape seeds.
const float WormFreq = PassageRandomRange(0.8f, 1.8f, PassageSaltWormFreq); // (vertical wobble only)
const float NSeedX = PassageRandomRange(0.0f, 500.0f, PassageSaltNoiseX);
const float NSeedY = PassageRandomRange(0.0f, 500.0f, PassageSaltNoiseY);
const float NSeedZ = PassageRandomRange(0.0f, 500.0f, PassageSaltNoiseZ);
const float PhaseA = PassageRandom01(PassageSaltPhase) * (2.0f * PI);
// Base fBM frequency for the worm's wander (octaves add finer detail on top).
const float BendFreq = PassageRandomRange(1.5f, 2.5f, PassageSaltBendFreq);
for (int32 s = 0; s <= Segments; s++)
{
const float T = (float)s / (float)Segments;
float Z = FMath::Lerp(TopZ, BottomZ, T);
const float Env = VoxelMath::DetSin(T * PI); // 0 at both ends → mouths stay anchored
float OX = 0.0f, OY = 0.0f;
switch (Cfg.Style)
{
case EVoxelPassageStyle::Straight:
// No authored lateral offset. A snapped lower mouth can still make this
// segment slanted, so the endpoint interpolation below remains intentional.
break;
case EVoxelPassageStyle::Spiral:
{
const float Ang = PhaseA + T * Cfg.SpiralTurns * 2.0f * PI;
float SinAng = 0.0f, CosAng = 0.0f;
VoxelMath::DetSinCos(SinAng, CosAng, Ang);
OX = CosAng * Cfg.SpiralRadius * Env;
OY = SinAng * Cfg.SpiralRadius * Env;
break;
}
case EVoxelPassageStyle::Cascading:
{
// Switchback staircase: each tread offsets in a new deterministic direction.
const int32 Steps = FMath::Clamp(Cfg.CascadeSteps, 1, 16);
const int32 Idx = FMath::Min((int32)(T * Steps), Steps - 1);
const float SA = PhaseA + (float)Idx * 2.39996f; // golden-angle spread
float SinSA = 0.0f, CosSA = 0.0f;
VoxelMath::DetSinCos(SinSA, CosSA, SA);
OX = CosSA * Cfg.CascadeLedge * Env;
OY = SinSA * Cfg.CascadeLedge * Env;
break;
}
case EVoxelPassageStyle::Worm:
default:
{
// SQUIRM: displace the descent independently on X and Y with multi-octave
// fBM (different seeds → uncorrelated). Independent fBM per axis is a true
// 2D organic wander — it curls and meanders "here and there" rather than
// oscillating along one line (zig-zag) or orbiting the axis (spiral).
// Flat-top envelope keeps full motion along the length but anchors the mouths.
const float WormEnv = FMath::Clamp(VoxelMath::DetSin(T * PI) * 3.0f, 0.0f, 1.0f);
OX = PassageFBM(T * BendFreq, NSeedX) * VOXEL_NOISE_SCALE * Cfg.Wander * WormEnv;
OY = PassageFBM(T * BendFreq, NSeedY + 53.0f) * VOXEL_NOISE_SCALE * Cfg.Wander * WormEnv;
break;
}
}
// Vertical wobble (all styles): dips/rises along the descent, anchored at ends.
if (Cfg.VerticalWobble > 0.0f)
{
const float NZ = FMath::PerlinNoise3D(FVector(T * WormFreq * 1.3f + NSeedZ, NSeedZ * 0.5f, 27.0f));
Z += NZ * VOXEL_NOISE_SCALE * Cfg.VerticalWobble * Env;
}
const float BaseX = FMath::Lerp(UpperX, LowerX, T);
const float BaseY = FMath::Lerp(UpperY, LowerY, T);
FVector ControlPoint(BaseX + OX, BaseY + OY, Z);
// The style envelope is mathematically zero at a mouth, but evaluating sin(PI)
// leaves a tiny float residue. Pin both endpoints so the full query result is the
// actual aimed mouth, including any lateral snap, and never merely an approximation.
if (s == 0)
{
ControlPoint = FVector(UpperX, UpperY, TopZ);
}
else if (s == Segments)
{
ControlPoint = FVector(LowerX, LowerY, BottomZ);
}
Passage.ControlPoints.Add(ControlPoint);
Passage.ControlRadii.Add(RadiusAt(T));
}
// The old control-point endpoints were also the player's standing points. That made
// a sloped/vertical tube open directly under the capsule. Keep the queried points as
// explicit standing anchors, and move only the tube's first/last point to a doorway
// tangent to the landing floor. The endpoint-to-anchor distinction is the geometry
// that turns a mouth into a place.
auto DoorDirectionFrom = [](const FVector& Delta, float Angle) -> FVector
{
FVector Direction(Delta.X, Delta.Y, 0.0f);
if (!Direction.Normalize())
{
float SinAngle = 0.0f, CosAngle = 0.0f;
VoxelMath::DetSinCos(SinAngle, CosAngle, Angle);
Direction = FVector(CosAngle, SinAngle, 0.0f);
if (!Direction.Normalize())
{
Direction = FVector(1.0f, 0.0f, 0.0f);
}
}
return Direction;
};
const FVector UpperDoorDirection = DoorDirectionFrom(
Passage.ControlPoints.Num() > 1
? Passage.ControlPoints[1] - Passage.ControlPoints[0]
: FVector::ZeroVector,
PassageRandom01(PassageSaltUpperDoor) * 2.0f * PI);
const FVector LowerDoorDirection = DoorDirectionFrom(
Passage.ControlPoints.Num() > 1
? Passage.ControlPoints[Passage.ControlPoints.Num() - 2]
- Passage.ControlPoints.Last()
: FVector::ZeroVector,
PassageRandom01(PassageSaltLowerDoor) * 2.0f * PI);
// A source-fit answer is the landing itself. Keep it local to the requested room: the
// (0,0) landing is reserved for the future straight shaft, so no radial connector is
// synthesized here.
Passage.UpperLanding = VF_BuildPassageLanding(
FVector(UpperX, UpperY, TopZ),
Cfg.MouthRadius,
UpperDoorDirection,
UpperTopZ,
UpperBottomZ,
UpperDef ? BoundarySealThicknessFor(*UpperDef) : 0.0f,
bAimedUpperAtPlayerFitPoint);
Passage.LowerLanding = VF_BuildPassageLanding(
FVector(LowerX, LowerY, BottomZ),
Cfg.MouthRadius,
LowerDoorDirection,
LowerTopZ,
(float)(Lower.BottomChunkZ) * CHUNK_SIZE,
LowerDef ? BoundarySealThicknessFor(*LowerDef) : 0.0f,
bAimedLowerAtPlayerFitPoint);
Passage.UpperPoint = Passage.UpperLanding.StandingPoint;
Passage.LowerPoint = Passage.LowerLanding.StandingPoint;
if (Cfg.Style == EVoxelPassageStyle::Straight
&& Passage.UpperLanding.HalfWidth > 0.0f
&& Passage.LowerLanding.HalfWidth > 0.0f)
{
// BASE CONNECTION: a walkable two-leg switchback. A direct line between the
// mouths would often be nearly vertical because both requests are placed at the
// same XY radius. Put the turn on the perpendicular bisector and give each leg
// at least half of the horizontal run required by the named 15-degree law.
// This is deliberately a construction rule, not a seed-dependent observation.
const float SwitchbackAngle =
PassageRandom01(PassageSaltUpperDoor) * 2.0f * PI;
float SinSwitchback = 0.0f, CosSwitchback = 0.0f;
VoxelMath::DetSinCos(SinSwitchback, CosSwitchback, SwitchbackAngle);
FVector2D SwitchbackDirection(CosSwitchback, SinSwitchback);
if (!SwitchbackDirection.Normalize())
{
SwitchbackDirection = FVector2D(1.0f, 0.0f);
}
const FVector DoorDirection(
SwitchbackDirection.X, SwitchbackDirection.Y, 0.0f);
Passage.UpperLanding.DoorDirection = DoorDirection;
// Keep both door approaches on the same outward side so each sloped leg reaches
// its own apron before entering the room. Separate their turn-side floor branches
// below so the two projections do not retrace one XY line at different heights.
const FVector TunnelLowerDoorDirection = DoorDirection;
Passage.LowerLanding.DoorDirection = TunnelLowerDoorDirection;
const float UpperDoorOffset = FMath::Max(
Passage.UpperLanding.HalfWidth - 1.0f, 0.0f);
const float LowerDoorOffset = FMath::Max(
Passage.LowerLanding.HalfWidth - 1.0f, 0.0f);
const float SafeMouthRadius = FMath::Max(
FMath::Abs(Cfg.MouthRadius), 1.0f);
Passage.UpperLanding.DoorPoint =
Passage.UpperLanding.StandingPoint + DoorDirection * UpperDoorOffset;
Passage.UpperLanding.DoorPoint.Z =
Passage.UpperLanding.FloorZ + SafeMouthRadius;
Passage.LowerLanding.DoorPoint =
Passage.LowerLanding.StandingPoint
+ TunnelLowerDoorDirection * LowerDoorOffset;
Passage.LowerLanding.DoorPoint.Z =
Passage.LowerLanding.FloorZ + SafeMouthRadius;
const FVector UpperDoor = Passage.UpperLanding.DoorPoint;
const FVector LowerDoor = Passage.LowerLanding.DoorPoint;
// Keep a short level apron beyond each room floor. The door anchor is one voxel
// inside the room's support square; a diagonal door direction can therefore need
// several voxels before it leaves that square and its four-voxel SDF blend.
// The level apron must clear the room half-width, the tube radius, and the
// smooth carve band before the sloped leg begins. The final six-voxel transition
// is measured from that clear point back toward the turn, so include it too. For
// the default 8-voxel half-width / 6-voxel mouth this is 17 voxels (4.25 m), not
// the old 6-voxel minimum that left the sloped capsule inside the landing room.
const float LandingApron = FMath::Max(
VoxelPassageGeometry::WalkableTunnelLandingApronVoxels,
VoxelPassageGeometry::WalkableTunnelTurnTransitionVoxels
+ SafeMouthRadius
+ VoxelPassageGeometry::LandingCarveBlendVoxels
+ 1.0f);
const FVector UpperApronEnd = UpperDoor
+ DoorDirection * LandingApron;
const FVector LowerApronBegin = LowerDoor
+ TunnelLowerDoorDirection * LandingApron;
const float VerticalDrop = FMath::Abs(UpperDoor.Z - LowerDoor.Z);
const float UpperFloorZ = VoxelPassageGeometry::TunnelFloorZ(
UpperDoor, Cfg.MouthRadius);
const float LowerFloorZ = VoxelPassageGeometry::TunnelFloorZ(
LowerDoor, Cfg.MouthRadius);
const float MidFloorZ = 0.5f * (UpperFloorZ + LowerFloorZ);
// Each ramp must leave its own landing on the outward side. The two doors face
// that same direction; orient the shared level turn along it, then split the lower
// floor branch laterally so the ramp projections remain unambiguous.
FVector2D UpperOutward(
UpperApronEnd.X - Passage.UpperLanding.StandingPoint.X,
UpperApronEnd.Y - Passage.UpperLanding.StandingPoint.Y);
FVector2D LowerOutward(
LowerApronBegin.X - Passage.LowerLanding.StandingPoint.X,
LowerApronBegin.Y - Passage.LowerLanding.StandingPoint.Y);
UpperOutward.Normalize();
LowerOutward.Normalize();
const float UpperFloorDrop = UpperFloorZ - MidFloorZ;
const float LowerFloorDrop = MidFloorZ - LowerFloorZ;
const float RequiredHorizontalRun =
VoxelPassageGeometry::RequiredHorizontalRunForFloorDrop(
UpperFloorDrop, LowerFloorDrop);
// Move the level turn farther than half the required run. Each slope then loses
// only the named transition length to its level segment and still retains the
// full horizontal run required by the 15-degree floor law.
const float TurnTransition =
VoxelPassageGeometry::WalkableTunnelTurnTransitionVoxels;
const float TurnOffset =
0.5f * RequiredHorizontalRun + TurnTransition;
FVector2D TurnDirection(
UpperOutward.X + LowerOutward.X,
UpperOutward.Y + LowerOutward.Y);
if (!TurnDirection.Normalize())
{
TurnDirection = UpperOutward;
}
const FVector2D ApronChord(
LowerApronBegin.X - UpperApronEnd.X,
LowerApronBegin.Y - UpperApronEnd.Y);
const float LowerApronAlong = FVector2D::DotProduct(
ApronChord, TurnDirection);
const float SharedTurnOffset = TurnOffset
+ FMath::Max(LowerApronAlong, 0.0f);
const FVector2D SharedTurnMid(
UpperApronEnd.X + TurnDirection.X * SharedTurnOffset,
UpperApronEnd.Y + TurnDirection.Y * SharedTurnOffset);
const float TurnLegSeparation =
VoxelPassageGeometry::WalkableTunnelTurnLegSeparation(
Cfg.MidRadius, Cfg.MouthRadius);
FVector2D TurnLegSideDirection(-TurnDirection.Y, TurnDirection.X);
if (FVector2D::DotProduct(ApronChord, TurnLegSideDirection) < 0.0f)
{
TurnLegSideDirection *= -1.0f;
}
const FVector2D UpperTurnMid = SharedTurnMid;
const FVector2D LowerTurnMid(
SharedTurnMid.X + TurnLegSideDirection.X * TurnLegSeparation,
SharedTurnMid.Y + TurnLegSideDirection.Y * TurnLegSeparation);
FVector2D UpperSlopeDirection(
UpperTurnMid.X - UpperApronEnd.X,
UpperTurnMid.Y - UpperApronEnd.Y);
if (!UpperSlopeDirection.Normalize())
{
UpperSlopeDirection = FVector2D(
DoorDirection.X, DoorDirection.Y);
}
FVector2D LowerSlopeDirection(
LowerApronBegin.X - LowerTurnMid.X,
LowerApronBegin.Y - LowerTurnMid.Y);
if (!LowerSlopeDirection.Normalize())
{
LowerSlopeDirection = -UpperSlopeDirection;
}
const FVector2D UpperSlopeStartXY(
UpperApronEnd.X + UpperSlopeDirection.X * TurnTransition,
UpperApronEnd.Y + UpperSlopeDirection.Y * TurnTransition);
const FVector2D LowerSlopeEndXY(
LowerApronBegin.X - LowerSlopeDirection.X * TurnTransition,
LowerApronBegin.Y - LowerSlopeDirection.Y * TurnTransition);
const FVector UpperApronEndPoint(
UpperApronEnd.X, UpperApronEnd.Y,
UpperFloorZ + FMath::Abs(Cfg.MouthRadius));
const FVector UpperSlopeStart(
UpperSlopeStartXY.X, UpperSlopeStartXY.Y,
UpperFloorZ + FMath::Abs(Cfg.MouthRadius));
const FVector MidPoint(
UpperTurnMid.X, UpperTurnMid.Y,
MidFloorZ + FMath::Abs(Cfg.MidRadius));
const FVector LowerTurnPoint(
LowerTurnMid.X, LowerTurnMid.Y,
MidFloorZ + FMath::Abs(Cfg.MidRadius));
const FVector LowerSlopeEnd(
LowerSlopeEndXY.X, LowerSlopeEndXY.Y,
LowerFloorZ + FMath::Abs(Cfg.MouthRadius));
const FVector LowerApronBeginPoint(
LowerApronBegin.X, LowerApronBegin.Y,
LowerFloorZ + FMath::Abs(Cfg.MouthRadius));
Passage.ControlPoints.Reset(8);
Passage.ControlRadii.Reset(8);
Passage.ControlPoints.Add(UpperDoor);
Passage.ControlPoints.Add(UpperApronEndPoint);
Passage.ControlPoints.Add(UpperSlopeStart);
Passage.ControlPoints.Add(MidPoint);
Passage.ControlPoints.Add(LowerTurnPoint);
Passage.ControlPoints.Add(LowerSlopeEnd);
Passage.ControlPoints.Add(LowerApronBeginPoint);
Passage.ControlPoints.Add(LowerDoor);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.ControlRadii.Add(Cfg.MidRadius);
Passage.ControlRadii.Add(Cfg.MidRadius);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.ControlRadii.Add(Cfg.MouthRadius);
Passage.PassageType = EVoxelPassageType::SlopedTunnel;
Passage.bWalkableTunnelContract = true;
Passage.TunnelMaxGradientDegrees =
VoxelPassageGeometry::WalkableTunnelMaxGradientDegrees;
Passage.TunnelVerticalDropVoxels = VerticalDrop;
Passage.TunnelRequiredHorizontalRunVoxels = RequiredHorizontalRun;
Passage.TunnelHorizontalPathLengthVoxels = 0.0f;
for (int32 ControlIndex = 0;
ControlIndex + 1 < Passage.ControlPoints.Num();
++ControlIndex)
{
Passage.TunnelHorizontalPathLengthVoxels += FVector2D(
Passage.ControlPoints[ControlIndex + 1].X
- Passage.ControlPoints[ControlIndex].X,
Passage.ControlPoints[ControlIndex + 1].Y
- Passage.ControlPoints[ControlIndex].Y).Size();
}
Passage.TunnelMinimumClearWidthVoxels = 2.0f * FMath::Max(
FMath::Min(FMath::Abs(Cfg.MouthRadius), FMath::Abs(Cfg.MidRadius)),
0.0f);
Passage.TunnelClearHeightVoxels = Passage.TunnelMinimumClearWidthVoxels;
}
else if (Passage.ControlPoints.Num() > 0)
{
Passage.ControlPoints[0] = Passage.UpperLanding.DoorPoint;
Passage.ControlPoints.Last() = Passage.LowerLanding.DoorPoint;
}
Passage.Radius = 0.0f;
for (const float ControlRadius : Passage.ControlRadii)
{
Passage.Radius = FMath::Max(Passage.Radius, ControlRadius);
}
// Fallback / bounds if an invalid authored width produced no positive profile.
Passage.Radius = FMath::Max(Passage.Radius, FMath::Max(Cfg.MouthRadius, Cfg.MidRadius));
// The passage now owns its D-section at construction time. Both landing floors,
// the complete control chain, and the room-derived relief source are known here;
// no voxel query needs to decide whether this particular passage deserves a floor.
VF_AuthorNativePassageFloor(
Passage, UpperDef, LowerDef,
PassageSeed ^ VoxelHash::Cell(i, c, PassageSeed));
// Bounding sphere over the tube, both rooms, and both floor slabs (+ widest radius +
// blend) for culling. Under-sizing this sphere would cull a real landing and leave a
// sealed pocket, so the room's full box diagonal is included rather than treating the
// standing anchor as a point.
{
FVector BoundsMin(FLT_MAX, FLT_MAX, FLT_MAX);
FVector BoundsMax(-FLT_MAX, -FLT_MAX, -FLT_MAX);
auto IncludePoint = [&BoundsMin, &BoundsMax](const FVector& Point, float Pad)
{
BoundsMin.X = FMath::Min(BoundsMin.X, Point.X - Pad);
BoundsMin.Y = FMath::Min(BoundsMin.Y, Point.Y - Pad);
BoundsMin.Z = FMath::Min(BoundsMin.Z, Point.Z - Pad);
BoundsMax.X = FMath::Max(BoundsMax.X, Point.X + Pad);
BoundsMax.Y = FMath::Max(BoundsMax.Y, Point.Y + Pad);
BoundsMax.Z = FMath::Max(BoundsMax.Z, Point.Z + Pad);
};
auto IncludeBounds = [&BoundsMin, &BoundsMax](
const FVector& Min, const FVector& Max)
{
BoundsMin.X = FMath::Min(BoundsMin.X, Min.X);
BoundsMin.Y = FMath::Min(BoundsMin.Y, Min.Y);
BoundsMin.Z = FMath::Min(BoundsMin.Z, Min.Z);
BoundsMax.X = FMath::Max(BoundsMax.X, Max.X);
BoundsMax.Y = FMath::Max(BoundsMax.Y, Max.Y);
BoundsMax.Z = FMath::Max(BoundsMax.Z, Max.Z);
};
for (const FVector& CP : Passage.ControlPoints)
{
IncludePoint(CP, Passage.Radius + 4.0f);
}
const auto IncludeLanding = [&IncludePoint](const FVoxelPassageLanding& Landing)
{
const float Height = FMath::Max(Landing.CeilingZ - Landing.FloorZ, 0.0f);
const FVector RoomCenter(
Landing.StandingPoint.X,
Landing.StandingPoint.Y,
(Landing.FloorZ + Landing.CeilingZ) * 0.5f);
const float RoomRadius = FMath::Sqrt(
2.0f * FMath::Square(Landing.HalfWidth)
+ 0.25f * FMath::Square(Height))
+ Landing.FloorThickness + 4.0f;
IncludePoint(RoomCenter, RoomRadius);
};
IncludeLanding(Passage.UpperLanding);
IncludeLanding(Passage.LowerLanding);
// These two MC writers run after the tunnel SDF: the native support slab uses
// the relieved floor profile, and the final corridor air envelope uses each
// segment's own relief branch plus the door-to-standing approaches. Include the
// actual write suprema so the chunk shortlist and all sphere-based proofs remain
// conservative even when the authored relief exceeds the old one-voxel reserve.
if (Passage.bWalkableTunnelContract && Passage.bNativeFloorEnabled)
{
constexpr float CorridorHalfWidth =
0.5f * VoxelPassageGeometry::WalkCorridorPlayerWidthVoxels
+ VoxelPassageGeometry::WalkCorridorLatticeMarginVoxels;
constexpr float CorridorBottom =
VoxelPassageGeometry::MaxStepHeightVoxels;
constexpr float CorridorTop = CorridorBottom
+ VoxelPassageGeometry::WalkCorridorPlayerHeightVoxels;
float ReliefBound = 0.0f;
if (VF_GetNativePassageFloorReliefBound(Passage, ReliefBound)
&& Passage.ControlPoints.Num() >= 2
&& Passage.ControlRadii.Num() == Passage.ControlPoints.Num())
{
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num();
++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float RadiusA =
FMath::Abs(Passage.ControlRadii[SegmentIndex]);
const float RadiusB =
FMath::Abs(Passage.ControlRadii[SegmentIndex + 1]);
const float FloorA =
Passage.NativeFloorProfileZ[SegmentIndex];
const float FloorB =
Passage.NativeFloorProfileZ[SegmentIndex + 1];
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y)
|| !VoxelMath::IsFinite(B.X) || !VoxelMath::IsFinite(B.Y)
|| !VoxelMath::IsFinite(FloorA)
|| !VoxelMath::IsFinite(FloorB))
{
continue;
}
const float SupportRadius =
VoxelPassageGeometry::NativePassageFloorSupportRadius(
RadiusA, RadiusB);
IncludeBounds(
FVector(
FMath::Min(A.X, B.X) - SupportRadius,
FMath::Min(A.Y, B.Y) - SupportRadius,
FMath::Min(FloorA, FloorB) - ReliefBound
- VoxelPassageGeometry::LandingFloorThicknessVoxels),
FVector(
FMath::Max(A.X, B.X) + SupportRadius,
FMath::Max(A.Y, B.Y) + SupportRadius,
FMath::Max(FloorA, FloorB) + ReliefBound
+ KINDA_SMALL_NUMBER));
IncludeBounds(
FVector(
FMath::Min(A.X, B.X) - CorridorHalfWidth,
FMath::Min(A.Y, B.Y) - CorridorHalfWidth,
FMath::Min(FloorA, FloorB) + CorridorBottom
- ReliefBound),
FVector(
FMath::Max(A.X, B.X) + CorridorHalfWidth,
FMath::Max(A.Y, B.Y) + CorridorHalfWidth,
FMath::Max(FloorA, FloorB) + CorridorTop
+ ReliefBound));
}
}
for (const FVoxelPassageLanding* Landing : {
&Passage.UpperLanding, &Passage.LowerLanding })
{
if (!VoxelMath::IsFinite(Landing->DoorPoint.X)
|| !VoxelMath::IsFinite(Landing->DoorPoint.Y)
|| !VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ))
{
continue;
}
const float LengthSquared = FVector2D::DistSquared(
FVector2D(Landing->DoorPoint.X, Landing->DoorPoint.Y),
FVector2D(Landing->StandingPoint.X, Landing->StandingPoint.Y));
if (!(LengthSquared > KINDA_SMALL_NUMBER)
|| !VoxelMath::IsFinite(LengthSquared))
{
continue;
}
IncludeBounds(
FVector(
FMath::Min(Landing->DoorPoint.X, Landing->StandingPoint.X)
- CorridorHalfWidth,
FMath::Min(Landing->DoorPoint.Y, Landing->StandingPoint.Y)
- CorridorHalfWidth,
Landing->FloorZ + CorridorBottom),
FVector(
FMath::Max(Landing->DoorPoint.X, Landing->StandingPoint.X)
+ CorridorHalfWidth,
FMath::Max(Landing->DoorPoint.Y, Landing->StandingPoint.Y)
+ CorridorHalfWidth,
Landing->FloorZ + CorridorTop));
}
}
const FVector Center = (BoundsMin + BoundsMax) * 0.5f;
float MaxDistSq = 0.0f;
MaxDistSq = FMath::Max(MaxDistSq, (float)FVector::DistSquared(Center, BoundsMin));
MaxDistSq = FMath::Max(MaxDistSq, (float)FVector::DistSquared(Center, BoundsMax));
const float R = FMath::Sqrt(MaxDistSq);
Passage.BoundCenter = Center;
Passage.BoundRadius = R;
Passage.BoundRadiusSq = R * R;
}
Passages.Add(Passage);
}
}
TArray<FString> SortedNoQueryArchetypes;
for (const FString& Archetype : NoQueryArchetypes)
{
SortedNoQueryArchetypes.Add(Archetype);
}
SortedNoQueryArchetypes.Sort();
FString NoQueryList = TEXT("none");
if (SortedNoQueryArchetypes.Num() > 0)
{
NoQueryList = FString::Join(SortedNoQueryArchetypes, TEXT(", "));
}
UE_LOG(LogTemp, Log,
TEXT("[StrateManager] Passage landings: upper %d/%d and lower %d/%d source-fit; %d/%d mouth queries fell back to random reach (archetypes with no query: %s)."),
NumAimedAtUpperPlayerFit,
TotalPassages,
NumAimedAtLowerPlayerFit,
TotalPassages,
(TotalPassages * 2) - NumAimedAtUpperPlayerFit - NumAimedAtLowerPlayerFit,
TotalPassages * 2,
*NoQueryList);
//=========================================================================
// SURFACE ENTRY — the one optional above-ground opening.
// It opens the top seal and stops at the ceiling of strate 0's origin landing room. It does
// not continue down the room or into lower strates: every lower seal remains closed until the
// corresponding progression passage is opened.
//=========================================================================
if (bOpenSurfaceEntry && OriginSpineRadius > 0.0f && StrateLayout.Num() > 0)
{
const FStrateSlot& Top = StrateLayout[0];
const float TopZ = (float)(Top.TopChunkZ + 1) * CHUNK_SIZE;
const float BottomZ = (float)Top.BottomChunkZ * CHUNK_SIZE;
const float TopSeal = Top.Definition
? BoundarySealThicknessFor(*Top.Definition) : 0.0f;
const VoxelPassageGeometry::FOriginLandingGeometry OriginLanding =
VoxelPassageGeometry::BuildOriginLandingGeometry(
TopZ, BottomZ, TopSeal, OriginSpineRadius);
if (!OriginLanding.bValid)
{
UE_LOG(LogTemp, Warning,
TEXT("[StrateManager] Surface entry skipped: top origin landing has no seal-safe room interval."));
}
else
{
FVoxelPassage Entry;
Entry.UpperStrateIndex = 0;
Entry.LowerStrateIndex = 0;
// Keep the legacy type: this is the explicitly opted-in above-ground vertical opening,
// not the default inter-strate descent style.
Entry.PassageType = EVoxelPassageType::VerticalShaft;
// Match the reserved future shaft envelope exactly. The entry is only opened through
// the top seal into the finite landing room; lower strate seals remain untouched.
Entry.Radius = FMath::Max(OriginSpineRadius, 1.0f);
Entry.UpperPoint = FVector(0.0f, 0.0f, TopZ + CHUNK_SIZE);
// The capsule's lower tangent meets the room ceiling; it never bores through the
// room's floor or creates an origin column in strate 0.
Entry.LowerPoint = FVector(
0.0f, 0.0f, OriginLanding.CeilingZ + Entry.Radius);
Entry.ControlPoints.Reset(2);
Entry.ControlPoints.Add(Entry.UpperPoint);
Entry.ControlPoints.Add(Entry.LowerPoint);
Entry.ControlRadii.Reset(2);
Entry.ControlRadii.Add(Entry.Radius);
Entry.ControlRadii.Add(Entry.Radius);
Entry.TunnelClearHeightVoxels = 2.0f * Entry.Radius;
Entry.TunnelMinimumClearWidthVoxels = 2.0f * Entry.Radius;
{
const FVector C = (Entry.UpperPoint + Entry.LowerPoint) * 0.5f;
const float R = (float)FVector::Dist(C, Entry.UpperPoint) + Entry.Radius + 4.0f;
Entry.BoundCenter = C;
Entry.BoundRadius = R;
Entry.BoundRadiusSq = R * R;
}
Passages.Add(Entry);
UE_LOG(LogTemp, Log,
TEXT("[StrateManager] Surface entry opening at (0,0) topZ=%.0f roomFloor=%.1f roomCeiling=%.1f R=%.1f"),
TopZ, OriginLanding.FloorZ, OriginLanding.CeilingZ, Entry.Radius);
}
}
VoxelForgeStartupTrace::RecordEvent(TEXT("passages_ready"), FString::Printf(
TEXT("\"passages\":%d,\"passages_version\":%u,\"upper_source_fit\":%d,\"lower_source_fit\":%d"),
Passages.Num(), PassagesVersion, NumAimedAtUpperPlayerFit, NumAimedAtLowerPlayerFit));
}
//=============================================================================
// MODIFIER SDF (inter-strate passages)
//=============================================================================
float UVoxelStrateManager::EvaluateModifierSDF(float WorldX, float WorldY, float WorldZ) const
{
VoxelGenLOD::FScopedReachCost ReachCost(
VoxelGenLOD::ETileReachCostKind::PassageCarving);
if (VoxelDensityAblation::IsPassageCarvingOff())
{
return FLT_MAX;
}
// GenerateMesh installs this once per tile/block. Outside the mesher the TLS defaults to
// the canonical all-reachable state, and debug canonical calls set the bypass bit explicitly.
// A miss is an identity for VF_ApplyPassageCarving, so do not even enter the spatial shortlist
// or capsule chain on a proven-far sample.
if (!VoxelGenLOD::IsTilePostReachBypassActive()
&& !VoxelGenLOD::IsPassageCarvingReachable())
{
return FLT_MAX;
}
// The landing terms are part of the passage modifier, so their reach proof is deliberately
// wider than the direct post's four-voxel blend: SmoothMin can lower a finite term by K/6 at
// each later combine. Outside that padded room domain, omitting the two landing evaluations
// is an identity for VF_ApplyPassageCarving.
const bool bEvaluateLandingSDF = VoxelGenLOD::IsPassageLandingReachable()
|| VoxelGenLOD::IsTilePostReachBypassActive();
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
// The shortlist is rebuilt once for a (manager, version, chunk) and is shared by the tube,
// landing, and floor paths. No source-fit stencil or topology search is allowed below it.
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
if (VoxelDensityProfile::AreCountersEnabled())
{
VoxelDensityProfile::AddCounter(
VoxelDensityProfile::ECounter::PassageCandidates,
static_cast<uint64>(Nearby.Num()));
}
if (Nearby.Num() == 0) return FLT_MAX; // no passage near this chunk → no carve
float MinSDF = FLT_MAX;
const float BlendK = 3.0f; // Smooth blend for passage junctions
const FVoxelPassage* PassageData = Passages.GetData();
//=========================================================================
// PASSAGES — tapered capsule chains between strates (per-strate PassageConfig).
// Each passage is a control-point chain with per-point radii; the (0,0) surface
// entry is a simple straight tube. A bounding-sphere reject skips far passages.
//=========================================================================
const FVector Pos(WorldX, WorldY, WorldZ);
for (int32 PIdx : Nearby)
{
const FVoxelPassage& P = PassageData[PIdx];
// BOUNDING-SPHERE REJECT: skip passages this voxel can't possibly be inside.
// EvaluateModifierSDF runs PER VOXEL; evaluating every passage's full capsule chain
// unconditionally is the dominant lag source with 12-segment worm passages. Far
// passages cost a single squared-distance compare.
if (FVector::DistSquared(Pos, P.BoundCenter) > P.BoundRadiusSq) continue;
if (VoxelDensityProfile::AreCountersEnabled())
{
VoxelDensityProfile::AddCounter(
VoxelDensityProfile::ECounter::PassageEvaluated);
}
const int32 ControlPointCount = P.ControlPoints.Num();
if (ControlPointCount >= 2)
{
// Tapered capsule chain along the control points. ControlRadii (if present)
// gives the per-point width so the tunnel can flare at the mouths and pinch
// in the middle; otherwise the uniform Radius is used.
const bool bTaper = (P.ControlRadii.Num() == P.ControlPoints.Num());
const FVector* ControlPointData = P.ControlPoints.GetData();
const float* ControlRadiusData = P.ControlRadii.GetData();
float PassageSDF = FLT_MAX;
for (int32 j = 0; j < ControlPointCount - 1; j++)
{
const float rA = bTaper ? ControlRadiusData[j] : P.Radius;
const float rB = bTaper ? ControlRadiusData[j + 1] : P.Radius;
float SegmentSDF = VoxelSDF::TaperedCapsule(
Pos, ControlPointData[j], ControlPointData[j + 1], rA, rB);
// Clip each capsule against its own floor profile before the route segments are
// unioned. A single nearest-floor projection after the union can select the
// neighboring leg of a switchback and leave a solid post in this segment.
if (P.bNativeFloorEnabled && !VoxelDensityAblation::IsNativeFloorOff())
{
float NativeFloorZ = 0.0f;
float NativeSupportRadius = 0.0f;
float FloorDistanceSquared = FLT_MAX;
float FloorHorizontalDistanceSquared = FLT_MAX;
if (VF_ProjectNativePassageFloorSegment(
P, j, Pos, NativeFloorZ, NativeSupportRadius,
FloorDistanceSquared, FloorHorizontalDistanceSquared,
this, PIdx))
{
SegmentSDF = VoxelSDF::SmoothMax(
SegmentSDF,
NativeFloorZ - static_cast<float>(Pos.Z),
BlendK * 0.35f);
}
}
PassageSDF = VoxelSDF::SmoothMin(PassageSDF, SegmentSDF, BlendK);
}
MinSDF = VoxelSDF::SmoothMin(MinSDF, PassageSDF, BlendK);
}
else
{
// Fallback: straight uniform tube Upper→Lower (e.g. the (0,0) surface entry).
const float PassageSDF = VoxelSDF::Capsule(Pos, P.UpperPoint, P.LowerPoint, P.Radius);
MinSDF = VoxelSDF::SmoothMin(MinSDF, PassageSDF, BlendK);
}
// A landing is a real room with a hard flat-floor half-space, not a sphere around the
// tube endpoint. It is the same fixed SDF geometry selected during GeneratePassages; it
// never performs a source query here and does not synthesize a radial root connector.
if (bEvaluateLandingSDF)
{
const float UpperLandingSDF = VF_EvaluatePassageLandingSDF(Pos, P.UpperLanding);
const float LowerLandingSDF = VF_EvaluatePassageLandingSDF(Pos, P.LowerLanding);
MinSDF = VoxelSDF::SmoothMin(MinSDF, UpperLandingSDF, BlendK);
MinSDF = VoxelSDF::SmoothMin(MinSDF, LowerLandingSDF, BlendK);
}
}
return MinSDF;
}
void UVoxelStrateManager::ApplyPassageModifier(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity, float SealThickness) const
{
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageModifier);
const bool bBypass = VoxelGenLOD::IsTilePostReachBypassActive();
const bool bCompareLandingModifier = VoxelGenLOD::bTilePostReachDebug
&& !VoxelGenLOD::IsPassageLandingReachable() && !bBypass;
float CanonicalModifierDensity = Density;
if (bCompareLandingModifier)
{
const bool PreviousBypass = VoxelGenLOD::bTilePostReachBypass;
VoxelGenLOD::bTilePostReachBypass = true;
const float CanonicalSDF = EvaluateModifierSDF(WorldX, WorldY, WorldZ);
VF_ApplyPassageCarving(
CanonicalModifierDensity, CanonicalSDF, BaseDensity, SealThickness);
VoxelGenLOD::bTilePostReachBypass = PreviousBypass;
}
if (!VoxelDensityAblation::IsPassageCarvingOff())
{
const float ModSDF = EvaluateModifierSDF(WorldX, WorldY, WorldZ);
VF_ApplyPassageCarving(Density, ModSDF, BaseDensity, SealThickness);
}
if (bCompareLandingModifier)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageLandingSDF,
!VoxelGenLOD::SameFloatBits(Density, CanonicalModifierDensity));
}
ApplyPassageLandingAir(Density, WorldX, WorldY, WorldZ, BaseDensity, SealThickness);
const bool bLandingReachable = VoxelGenLOD::IsPassageLandingReachable()
|| VoxelGenLOD::IsTilePostReachBypassActive();
const bool bStructuralReachable = VoxelGenLOD::IsPassageStructuralReachable()
|| VoxelGenLOD::IsTilePostReachBypassActive();
if (!bLandingReachable && !bStructuralReachable)
{
return;
}
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
for (const int32 PassageIndex : Nearby)
{
const FVoxelPassage& Passage = PassageData[PassageIndex];
const bool bLandingFloor = bLandingReachable
&& !VoxelDensityAblation::IsLandingPostsOff()
&& (VF_IsPassageLandingFloor(Position, Passage.UpperLanding)
|| VF_IsPassageLandingFloor(Position, Passage.LowerLanding));
const bool bLegacySupportFloor = bStructuralReachable
&& !VoxelDensityAblation::IsPassageStructuralPostsOff()
&& bPassageSupportFloorWritesEnabled
&& !Passage.bNativeFloorEnabled
&& VF_IsWalkableTunnelFloor(Passage, Position, this, PassageIndex);
if (!VoxelPassageGeometry::VerticalShaftConnectorAirMarker()
&& (bLandingFloor || bLegacySupportFloor))
{
// This is the one bidirectional part of PassageCarveOp: a floor is a proved solid
// support slab. It is deliberately applied after the air carve so a tube can never
// tunnel through the floor and leave the player over a void.
Density = FMath::Max(Density, BaseDensity);
break;
}
}
// A neighbouring passage may own a floor at this XY while this point is in the air core of
// the current walkable tunnel. Reassert tunnel air after all floor posts so overlap cannot
// turn a valid route into a solid plug. At the tunnel's own floor the air predicate is false,
// so the support plane remains solid.
if (bStructuralReachable)
{
ApplyPassageTunnelAir(Density, WorldX, WorldY, WorldZ, BaseDensity, SealThickness);
}
}
void UVoxelStrateManager::ApplyPassageCarvingOnly(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity, float SealThickness) const
{
if (VoxelDensityAblation::IsPassageCarvingOff())
{
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageModifier);
const bool bBypass = VoxelGenLOD::IsTilePostReachBypassActive();
const bool bCompareLandingModifier = VoxelGenLOD::bTilePostReachDebug
&& !VoxelGenLOD::IsPassageLandingReachable() && !bBypass;
float CanonicalModifierDensity = Density;
if (bCompareLandingModifier)
{
const bool PreviousBypass = VoxelGenLOD::bTilePostReachBypass;
VoxelGenLOD::bTilePostReachBypass = true;
const float CanonicalSDF = EvaluateModifierSDF(WorldX, WorldY, WorldZ);
VF_ApplyPassageCarving(
CanonicalModifierDensity, CanonicalSDF, BaseDensity, SealThickness);
VoxelGenLOD::bTilePostReachBypass = PreviousBypass;
}
const float ModSDF = EvaluateModifierSDF(WorldX, WorldY, WorldZ);
VF_ApplyPassageCarving(Density, ModSDF, BaseDensity, SealThickness);
if (bCompareLandingModifier)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageLandingSDF,
!VoxelGenLOD::SameFloatBits(Density, CanonicalModifierDensity));
}
}
void UVoxelStrateManager::ApplyPassageLandingAir(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity, float SealThickness) const
{
if (VoxelDensityAblation::IsLandingPostsOff())
{
return;
}
if (!VoxelGenLOD::IsPassageLandingReachable()
&& !VoxelGenLOD::IsTilePostReachBypassActive())
{
VoxelGenLOD::CompareSkippedPost(Density, [&]()
{
ApplyPassageLandingAir(
Density, WorldX, WorldY, WorldZ, BaseDensity, SealThickness);
}, VoxelGenLOD::ETilePostComparisonKind::PassageLandingAir);
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageLandingAir);
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
if (Nearby.Num() == 0) return;
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
// A smooth room blend may overlap the end of a ramp. The analytic support plane owns that
// overlap; otherwise landing air can erase the tunnel's final-density floor after the tunnel
// air post has deliberately stopped above it.
if (VF_IsAnyPassageFloorAt(this, Position))
{
return;
}
float MinLandingSDF = FLT_MAX;
for (const int32 PassageIndex : Nearby)
{
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (FVector::DistSquared(Position, Passage.BoundCenter) > Passage.BoundRadiusSq)
{
continue;
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
const float LandingSDF = VF_EvaluatePassageLandingSDF(Position, *Landing);
if (LandingSDF < MinLandingSDF)
{
MinLandingSDF = LandingSDF;
}
}
}
if (MinLandingSDF == FLT_MAX) return;
// Keep the same smooth interior blend used by the passage op. This landing-specific writer is
// idempotent because the MC-facing post may run after the structural op already saw the same
// voxel. The landing's support floor is restored by the floor writer after this MC-facing pass.
VF_ApplyPassageLandingCarving(Density, MinLandingSDF, BaseDensity, SealThickness);
}
void UVoxelStrateManager::ApplyPassageTunnelAir(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity, float SealThickness) const
{
if (VoxelDensityAblation::IsPassageStructuralPostsOff())
{
return;
}
if (!VoxelGenLOD::IsPassageStructuralReachable()
&& !VoxelGenLOD::IsTilePostReachBypassActive())
{
VoxelGenLOD::CompareSkippedPost(Density, [&]()
{
ApplyPassageTunnelAir(
Density, WorldX, WorldY, WorldZ, BaseDensity, SealThickness);
}, VoxelGenLOD::ETilePostComparisonKind::PassageTunnelAir);
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageTunnelAir);
const FVector Position(WorldX, WorldY, WorldZ);
int32 PassageIndex = INDEX_NONE;
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
const bool bFoundWalkableAir = VF_FindWalkableTunnelAir(
this, Position, PassageIndex, FloorZ, SupportRadius);
if (bFoundWalkableAir)
{
const float AirTarget = -(BaseDensity * 2.0f + SealThickness + 4.0f);
Density = FMath::Min(Density, AirTarget);
}
}
void UVoxelStrateManager::ApplyPassageLandingFloorMC(
float& Density, float WorldX, float WorldY, float WorldZ, float BaseDensity) const
{
if (VoxelDensityAblation::IsLandingPostsOff()
&& VoxelDensityAblation::IsPassageStructuralPostsOff())
{
return;
}
const bool bBypass = VoxelGenLOD::IsTilePostReachBypassActive();
const bool bLandingReachable = VoxelGenLOD::IsPassageLandingReachable() || bBypass;
const bool bStructuralReachable = VoxelGenLOD::IsPassageStructuralReachable() || bBypass;
const bool bCompareLanding = VoxelGenLOD::bTilePostReachDebug
&& !bLandingReachable && !bBypass;
float CanonicalDensity = Density;
if (bCompareLanding)
{
const bool PreviousBypass = VoxelGenLOD::bTilePostReachBypass;
VoxelGenLOD::bTilePostReachBypass = true;
ApplyPassageLandingFloorMC(
CanonicalDensity, WorldX, WorldY, WorldZ, BaseDensity);
VoxelGenLOD::bTilePostReachBypass = PreviousBypass;
}
if (!bLandingReachable && !bStructuralReachable)
{
if (bCompareLanding)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageLandingFloor,
!VoxelGenLOD::SameFloatBits(Density, CanonicalDensity));
}
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageLandingFloor);
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
for (const int32 PassageIndex : Nearby)
{
const FVoxelPassage& Passage = PassageData[PassageIndex];
const bool bLandingFloor = bLandingReachable
&& !VoxelDensityAblation::IsLandingPostsOff()
&& (VF_IsPassageLandingFloor(Position, Passage.UpperLanding)
|| VF_IsPassageLandingFloor(Position, Passage.LowerLanding));
const bool bLegacySupportFloor = bStructuralReachable
&& !VoxelDensityAblation::IsPassageStructuralPostsOff()
&& bPassageSupportFloorWritesEnabled
&& !Passage.bNativeFloorEnabled
&& VF_IsWalkableTunnelFloor(Passage, Position, this, PassageIndex);
if (!VoxelPassageGeometry::VerticalShaftConnectorAirMarker()
&& (bLandingFloor || bLegacySupportFloor))
{
// Result is in MC convention here (negative = solid). This reassertion is the
// structural floor backstop after the optional MC-space disturbance layer.
Density = FMath::Min(Density, -BaseDensity);
break;
}
}
if (bCompareLanding)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageLandingFloor,
!VoxelGenLOD::SameFloatBits(Density, CanonicalDensity));
}
}
static bool VF_IsPassageRoomFloor(
const FVector& Position, const FVoxelPassageLanding& Landing)
{
if (!VoxelMath::IsFinite(Position.X) || !VoxelMath::IsFinite(Position.Y)
|| !VoxelMath::IsFinite(Position.Z) || !VoxelMath::IsFinite(Landing.FloorZ)
|| !VoxelMath::IsFinite(Landing.FloorThickness)
|| Landing.FloorThickness <= 0.0f || Landing.HalfWidth <= 0.0f)
{
return false;
}
return Position.Z <= Landing.FloorZ + KINDA_SMALL_NUMBER
&& Position.Z > Landing.FloorZ - Landing.FloorThickness
&& FMath::Abs(Position.X - Landing.StandingPoint.X)
<= FMath::Max(Landing.HalfWidth - 1.0f, 0.0f)
&& FMath::Abs(Position.Y - Landing.StandingPoint.Y)
<= FMath::Max(Landing.HalfWidth - 1.0f, 0.0f);
}
void UVoxelStrateManager::ApplyPassageStructuralPostsMC(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity, float SealThickness) const
{
const bool bDisableStructuralPosts = VoxelDensityAblation::IsPassageStructuralPostsOff();
const bool bDisableLandingPosts = VoxelDensityAblation::IsLandingPostsOff();
if (bDisableStructuralPosts && bDisableLandingPosts)
{
return;
}
const bool bBypass = VoxelGenLOD::IsTilePostReachBypassActive();
const bool bLandingReachable = VoxelGenLOD::IsPassageLandingReachable() || bBypass;
const bool bStructuralReachable = VoxelGenLOD::IsPassageStructuralReachable() || bBypass;
const bool bCompareLanding = VoxelGenLOD::bTilePostReachDebug
&& !bLandingReachable && !bBypass;
float CanonicalDensity = Density;
if (bCompareLanding)
{
const bool PreviousBypass = VoxelGenLOD::bTilePostReachBypass;
VoxelGenLOD::bTilePostReachBypass = true;
ApplyPassageStructuralPostsMC(
CanonicalDensity, WorldX, WorldY, WorldZ,
BaseDensity, SealThickness);
VoxelGenLOD::bTilePostReachBypass = PreviousBypass;
}
if (!bLandingReachable && !bStructuralReachable)
{
if (bCompareLanding)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageStructuralPosts,
!VoxelGenLOD::SameFloatBits(Density, CanonicalDensity));
}
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageStructuralPosts);
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
if (Nearby.Num() == 0) return;
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
const bool bSuppressFloor =
VoxelPassageGeometry::VerticalShaftConnectorAirMarker();
bool bAnyLandingFloor = false;
bool bLegacyTunnelSupportFloor = false;
bool bAnyRoomFloor = false;
bool bWalkableAir = false;
float MinLandingSDF = FLT_MAX;
// The four old MC backstops all walked the same immutable per-chunk shortlist. Gather their
// predicates in one pass; the writes below retain the old order (landing air, landing floor,
// tunnel air, room floor), including the vertical-shaft floor suppression marker.
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex)) continue;
const FVoxelPassage& Passage = PassageData[PassageIndex];
const bool bTunnelSupportFloor =
bStructuralReachable && !bDisableStructuralPosts
&& bPassageSupportFloorWritesEnabled
&& !Passage.bNativeFloorEnabled
&& VF_IsWalkableTunnelFloor(Passage, Position, this, PassageIndex);
if (!bSuppressFloor && bLandingReachable && !bDisableLandingPosts
&& (VF_IsPassageLandingFloor(Position, Passage.UpperLanding)
|| VF_IsPassageLandingFloor(Position, Passage.LowerLanding)))
{
bAnyLandingFloor = true;
}
if (!bSuppressFloor && bStructuralReachable
&& !bDisableStructuralPosts && bTunnelSupportFloor)
{
bLegacyTunnelSupportFloor = true;
}
if (!bSuppressFloor && bLandingReachable && !bDisableLandingPosts
&& (VF_IsPassageRoomFloor(Position, Passage.UpperLanding)
|| VF_IsPassageRoomFloor(Position, Passage.LowerLanding)))
{
bAnyRoomFloor = true;
}
if (bStructuralReachable && !bDisableStructuralPosts && !bWalkableAir
&& FVector::DistSquared(Position, Passage.BoundCenter) <= Passage.BoundRadiusSq
&& VF_IsWalkableTunnelAir(Passage, Position, this, PassageIndex))
{
bWalkableAir = true;
}
if (bLandingReachable && !bDisableLandingPosts
&& FVector::DistSquared(Position, Passage.BoundCenter) <= Passage.BoundRadiusSq)
{
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
MinLandingSDF = FMath::Min(
MinLandingSDF,
VF_EvaluatePassageLandingSDF(Position, *Landing));
}
}
}
// The graph tunnel does not expose a separate support slab. Inter-strate landing carving
// is independent and is composed here when its own reach proof allows it.
if (!bDisableLandingPosts
&& !bAnyLandingFloor && !bLegacyTunnelSupportFloor && MinLandingSDF < FLT_MAX)
{
float InternalDensity = -Density;
VF_ApplyPassageLandingCarving(
InternalDensity, MinLandingSDF, BaseDensity, SealThickness);
Density = -InternalDensity;
}
if (bAnyLandingFloor || bLegacyTunnelSupportFloor)
{
Density = FMath::Min(Density, -BaseDensity);
}
if (bWalkableAir)
{
Density = FMath::Max(
Density, BaseDensity * 2.0f + SealThickness + 4.0f);
}
if (bAnyRoomFloor)
{
Density = FMath::Min(Density, -BaseDensity);
}
if (bLegacyTunnelSupportFloor && VoxelDensityProfile::AreCountersEnabled())
{
VoxelDensityProfile::AddCounter(
VoxelDensityProfile::ECounter::PassageSupportFloorBackstopFires);
}
if (bCompareLanding)
{
VoxelGenLOD::RecordSkippedPostComparison(
VoxelGenLOD::ETilePostComparisonKind::PassageStructuralPosts,
!VoxelGenLOD::SameFloatBits(Density, CanonicalDensity));
}
}
void UVoxelStrateManager::ApplyPassageNativeFloorMC(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity) const
{
if (VoxelDensityAblation::IsNativeFloorOff())
{
return;
}
if (!VoxelGenLOD::IsPassageStructuralReachable()
&& !VoxelGenLOD::IsTilePostReachBypassActive())
{
VoxelGenLOD::CompareSkippedPost(Density, [&]()
{
ApplyPassageNativeFloorMC(Density, WorldX, WorldY, WorldZ, BaseDensity);
}, VoxelGenLOD::ETilePostComparisonKind::PassageNativeFloor);
return;
}
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
if (Nearby.Num() == 0
|| VoxelPassageGeometry::VerticalShaftConnectorAirMarker())
{
return;
}
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
bool bRoomOwnershipChecked = false;
bool bInsidePassageRoom = false;
const auto IsInsidePassageRoom = [&]()
{
if (!bRoomOwnershipChecked)
{
bRoomOwnershipChecked = true;
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex))
{
continue;
}
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (VF_EvaluatePassageLandingSDF(Position, Passage.UpperLanding) <= 0.0f
|| VF_EvaluatePassageLandingSDF(Position, Passage.LowerLanding) <= 0.0f)
{
bInsidePassageRoom = true;
break;
}
}
}
return bInsidePassageRoom;
};
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex))
{
continue;
}
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (!Passage.bNativeFloorEnabled)
{
continue;
}
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
if (VF_ProjectNativePassageFloor(
Passage, Position, FloorZ, SupportRadius, this, PassageIndex)
&& Position.Z <= FloorZ + KINDA_SMALL_NUMBER
&& Position.Z > FloorZ
- VoxelPassageGeometry::LandingFloorThicknessVoxels)
{
// Room geometry is strate A and owns every overlap. A tunnel's native post must not
// put a floor patch through a landing room; its own room-floor writer owns support.
if (!IsInsidePassageRoom())
{
// Keep the existing narrow floor surface on the segment selected by the passage's
// full 3D centerline, so a switchback's XY-near neighbor cannot add a second post.
Density = FMath::Min(Density, -FMath::Max(BaseDensity, 1.0f));
if (VoxelDensityProfile::AreCountersEnabled())
{
VoxelDensityProfile::AddCounter(
VoxelDensityProfile::ECounter::PassageNativeFloorCompositions);
}
}
break;
}
}
// Eval, terrain operations, and disturbance writers have all run before this MC-facing
// composition point. Reassert the walkable passage's swept body volume here so their solid
// features cannot put a rib or a neighboring floor post back through the through-route.
// The profile is evaluated per route segment: switchback legs keep their own floor branch.
// Room interiors stay owned by the room SDF, and the floor band remains untouched below the
// maximum legal step. This is an air carve over the tunnel's own shape, not a support slab.
const float CorridorHalfWidth =
0.5f * VoxelPassageGeometry::WalkCorridorPlayerWidthVoxels
+ VoxelPassageGeometry::WalkCorridorLatticeMarginVoxels;
const float CorridorBottom = VoxelPassageGeometry::MaxStepHeightVoxels;
const float CorridorTop = CorridorBottom
+ VoxelPassageGeometry::WalkCorridorPlayerHeightVoxels;
bool bInsideWalkCorridor = false;
for (const int32 PassageIndex : Nearby)
{
if (!Passages.IsValidIndex(PassageIndex))
{
continue;
}
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (!Passage.bWalkableTunnelContract || !Passage.bNativeFloorEnabled)
{
continue;
}
const int32 NumSegments = Passage.ControlPoints.Num() - 1;
for (int32 SegmentIndex = 0; SegmentIndex < NumSegments; ++SegmentIndex)
{
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
float DistanceSquared = FLT_MAX;
float HorizontalDistanceSquared = FLT_MAX;
if (!VF_ProjectNativePassageFloorSegment(
Passage, SegmentIndex, Position,
FloorZ, SupportRadius, DistanceSquared,
HorizontalDistanceSquared, this, PassageIndex)
|| HorizontalDistanceSquared > FMath::Square(CorridorHalfWidth))
{
continue;
}
const float HeightAboveFloor = Position.Z - FloorZ;
if (HeightAboveFloor >= CorridorBottom
&& HeightAboveFloor <= CorridorTop)
{
bInsideWalkCorridor = true;
break;
}
}
// The audited A-to-B path continues from each mouth to the landing's standing point.
// Cover those short approach lines too, while letting the actual landing room retain A
// ownership wherever its room SDF contains the query.
const auto IsInsideLandingApproach = [&](const FVoxelPassageLanding& Landing)
{
const FVector2D Start(Landing.DoorPoint.X, Landing.DoorPoint.Y);
const FVector2D End(Landing.StandingPoint.X, Landing.StandingPoint.Y);
const FVector2D Delta = End - Start;
const float LengthSquared = Delta.SizeSquared();
if (!(LengthSquared > KINDA_SMALL_NUMBER))
{
return false;
}
const FVector2D Query(Position.X, Position.Y);
const float T = FMath::Clamp(
FVector2D::DotProduct(Query - Start, Delta) / LengthSquared,
0.0f, 1.0f);
const FVector2D Closest = Start + Delta * T;
if (FVector2D::DistSquared(Query, Closest)
> FMath::Square(CorridorHalfWidth))
{
return false;
}
const float HeightAboveFloor = Position.Z - Landing.FloorZ;
return HeightAboveFloor >= CorridorBottom
&& HeightAboveFloor <= CorridorTop;
};
if (!bInsideWalkCorridor
&& (IsInsideLandingApproach(Passage.UpperLanding)
|| IsInsideLandingApproach(Passage.LowerLanding)))
{
bInsideWalkCorridor = true;
}
if (bInsideWalkCorridor)
{
break;
}
}
if (bInsideWalkCorridor)
{
if (!IsInsidePassageRoom())
{
Density = FMath::Max(Density, FMath::Max(BaseDensity, 1.0f));
}
}
}
void UVoxelStrateManager::ApplyPassageLandingRoomFloorMC(
float& Density, float WorldX, float WorldY, float WorldZ,
float BaseDensity) const
{
if (VoxelDensityAblation::IsLandingPostsOff())
{
return;
}
if (!VoxelGenLOD::IsPassageLandingReachable()
&& !VoxelGenLOD::IsTilePostReachBypassActive())
{
VoxelGenLOD::CompareSkippedPost(Density, [&]()
{
ApplyPassageLandingRoomFloorMC(
Density, WorldX, WorldY, WorldZ, BaseDensity);
}, VoxelGenLOD::ETilePostComparisonKind::PassageLandingRoomFloor);
return;
}
VoxelDensityProfile::FScopedTimer ProfileTimer(
VoxelDensityProfile::EBucket::PassageLandingRoomFloor);
const FIntVector ChunkCoord(
FMath::FloorToInt(WorldX / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldY / (float)CHUNK_SIZE),
FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE));
const TArray<int32>& Nearby = VF_GetNearbyPassages(this, ChunkCoord);
const FVoxelPassage* PassageData = Passages.GetData();
const FVector Position(WorldX, WorldY, WorldZ);
for (const int32 PassageIndex : Nearby)
{
const FVoxelPassage& Passage = PassageData[PassageIndex];
if (!VoxelPassageGeometry::VerticalShaftConnectorAirMarker()
&& (VF_IsPassageRoomFloor(Position, Passage.UpperLanding)
|| VF_IsPassageRoomFloor(Position, Passage.LowerLanding)))
{
Density = FMath::Min(Density, -BaseDensity);
break;
}
}
}
bool UVoxelStrateManager::AnyPassageNearBox(const FVector& MinVoxel, const FVector& MaxVoxel) const
{
if (VoxelDensityAblation::IsPassageCarvingOff())
{
return false;
}
// Le carve d'un passage atteint ModSDF < PASSAGE_BLEND_RADIUS (4, VoxelGenerator.cpp) au-delà de
// sa surface ; BoundRadius inclut déjà rayon + blend, on re-pad par sécurité (conservatif).
constexpr float CarvePad = 4.0f;
for (const FVoxelPassage& P : Passages)
{
// Point de la boîte le plus proche du centre de la sphère → test sphère/AABB.
const FVector C(
FMath::Clamp(P.BoundCenter.X, MinVoxel.X, MaxVoxel.X),
FMath::Clamp(P.BoundCenter.Y, MinVoxel.Y, MaxVoxel.Y),
FMath::Clamp(P.BoundCenter.Z, MinVoxel.Z, MaxVoxel.Z));
const float Reach = P.BoundRadius + CarvePad;
if (FVector::DistSquared(C, P.BoundCenter) <= Reach * Reach)
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyPassageLandingFloorNearBox(
const FVector& MinVoxel, const FVector& MaxVoxel) const
{
// A conservative AABB test is enough for the floor's only solid write. False positives cost
// a tile; a false negative could classify an air tile uniformly and remove the player's floor.
for (const FVoxelPassage& Passage : Passages)
{
float ReliefBound = 0.0f;
if (!VF_GetNativePassageFloorReliefBound(Passage, ReliefBound))
{
return true;
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (Landing->HalfWidth <= 0.0f || Landing->FloorThickness <= 0.0f)
{
continue;
}
const float Pad = 1.0f;
const float FloorMinX = Landing->StandingPoint.X - Landing->HalfWidth - Pad;
const float FloorMaxX = Landing->StandingPoint.X + Landing->HalfWidth + Pad;
const float FloorMinY = Landing->StandingPoint.Y - Landing->HalfWidth - Pad;
const float FloorMaxY = Landing->StandingPoint.Y + Landing->HalfWidth + Pad;
const float FloorMinZ = Landing->FloorZ - Landing->FloorThickness - Pad;
const float FloorMaxZ = Landing->FloorZ + Pad;
if (FloorMaxX >= MinVoxel.X && FloorMinX <= MaxVoxel.X
&& FloorMaxY >= MinVoxel.Y && FloorMinY <= MaxVoxel.Y
&& FloorMaxZ >= MinVoxel.Z && FloorMinZ <= MaxVoxel.Z)
{
return true;
}
}
// The default tube also owns a three-voxel support band. Its conservative segment AABB
// keeps a classifier from proving AllAir over the floor and then dropping that support
// during meshing. False positives are intentional; false negatives would be a hole.
if (Passage.bWalkableTunnelContract)
{
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return true;
}
constexpr float Pad = 1.0f;
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num();
++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y)
|| !VoxelMath::IsFinite(A.Z) || !VoxelMath::IsFinite(B.X)
|| !VoxelMath::IsFinite(B.Y) || !VoxelMath::IsFinite(B.Z)
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex])
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex + 1]))
{
return true;
}
const float RadiusA = FMath::Abs(Passage.ControlRadii[SegmentIndex]);
const float RadiusB = FMath::Abs(Passage.ControlRadii[SegmentIndex + 1]);
const float SupportRadius =
VoxelPassageGeometry::NativePassageFloorSupportRadius(RadiusA, RadiusB);
const float FloorA = Passage.bNativeFloorEnabled
? Passage.NativeFloorProfileZ[SegmentIndex]
: VoxelPassageGeometry::TunnelFloorZ(A, RadiusA);
const float FloorB = Passage.bNativeFloorEnabled
? Passage.NativeFloorProfileZ[SegmentIndex + 1]
: VoxelPassageGeometry::TunnelFloorZ(B, RadiusB);
const float FloorMinZ = FMath::Min(FloorA, FloorB)
- VoxelPassageGeometry::LandingFloorThicknessVoxels
- Pad - ReliefBound;
const float FloorMaxZ = FMath::Max(FloorA, FloorB)
+ Pad + ReliefBound;
const float FloorMinX = FMath::Min(A.X, B.X) - SupportRadius - Pad;
const float FloorMaxX = FMath::Max(A.X, B.X) + SupportRadius + Pad;
const float FloorMinY = FMath::Min(A.Y, B.Y) - SupportRadius - Pad;
const float FloorMaxY = FMath::Max(A.Y, B.Y) + SupportRadius + Pad;
if (FloorMaxX >= MinVoxel.X && FloorMinX <= MaxVoxel.X
&& FloorMaxY >= MinVoxel.Y && FloorMinY <= MaxVoxel.Y
&& FloorMaxZ >= MinVoxel.Z && FloorMinZ <= MaxVoxel.Z)
{
return true;
}
}
}
}
return false;
}
namespace
{
static bool VF_LatticeAxisRange(
float Min, float Max, float Origin, int32 Step,
int32& OutFirst, int32& OutLast)
{
if (Step <= 0 || !VoxelMath::IsFinite(Min) || !VoxelMath::IsFinite(Max)
|| !VoxelMath::IsFinite(Origin) || Min > Max)
{
return false;
}
const float InvStep = 1.0f / static_cast<float>(Step);
OutFirst = FMath::CeilToInt((Min - Origin) * InvStep - 1.0e-4f);
OutLast = FMath::FloorToInt((Max - Origin) * InvStep + 1.0e-4f);
return OutFirst <= OutLast;
}
struct FVoxelPassageModifierDomain
{
FVector Min = FVector(FLT_MAX, FLT_MAX, FLT_MAX);
FVector Max = FVector(-FLT_MAX, -FLT_MAX, -FLT_MAX);
};
static bool VF_LatticeBoxTouchesAABB(
const FBox& Box, const FIntVector& Origin, int32 Step,
float MinX, float MaxX, float MinY, float MaxY, float MinZ, float MaxZ);
static bool VF_BuildPassageModifierDomains(
const TArray<FVoxelPassage>& Passages,
TArray<FVoxelPassageModifierDomain, TInlineAllocator<128>>& Domains)
{
constexpr int32 MaxControlPointsForBound = 4096;
Domains.Reset();
auto AddDomain = [&](const FVector& Min, const FVector& Max) -> bool
{
if (!VoxelMath::IsFinite(Min.X) || !VoxelMath::IsFinite(Min.Y)
|| !VoxelMath::IsFinite(Min.Z) || !VoxelMath::IsFinite(Max.X)
|| !VoxelMath::IsFinite(Max.Y) || !VoxelMath::IsFinite(Max.Z)
|| Min.X > Max.X || Min.Y > Max.Y || Min.Z > Max.Z)
{
return false;
}
Domains.Add({Min, Max});
return true;
};
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
// Invalid generated geometry is an unknown, not an empty passage set.
return false;
}
if (Passage.ControlPoints.Num() >= 2)
{
if (Passage.ControlPoints.Num() > MaxControlPointsForBound)
{
return false;
}
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
if (!bTaper && !VoxelMath::IsFinite(Passage.Radius))
{
return false;
}
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num(); ++PointIndex)
{
const FVector& Point = Passage.ControlPoints[PointIndex];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z))
{
return false;
}
if (bTaper && !VoxelMath::IsFinite(Passage.ControlRadii[PointIndex]))
{
return false;
}
}
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float RadiusA = bTaper
? Passage.ControlRadii[SegmentIndex] : Passage.Radius;
const float RadiusB = bTaper
? Passage.ControlRadii[SegmentIndex + 1] : Passage.Radius;
const float Radius = FMath::Max(FMath::Abs(RadiusA), FMath::Abs(RadiusB));
if (!VoxelMath::IsFinite(Radius))
{
return false;
}
if (!AddDomain(
FVector(FMath::Min(A.X, B.X) - Radius,
FMath::Min(A.Y, B.Y) - Radius,
FMath::Min(A.Z, B.Z) - Radius),
FVector(FMath::Max(A.X, B.X) + Radius,
FMath::Max(A.Y, B.Y) + Radius,
FMath::Max(A.Z, B.Z) + Radius)))
{
return false;
}
}
}
else
{
if (!VoxelMath::IsFinite(Passage.UpperPoint.X)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Y)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Z)
|| !VoxelMath::IsFinite(Passage.LowerPoint.X)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Y)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Z)
|| !VoxelMath::IsFinite(Passage.Radius))
{
return false;
}
const float Radius = FMath::Abs(Passage.Radius);
if (!AddDomain(
FVector(FMath::Min(Passage.UpperPoint.X, Passage.LowerPoint.X) - Radius,
FMath::Min(Passage.UpperPoint.Y, Passage.LowerPoint.Y) - Radius,
FMath::Min(Passage.UpperPoint.Z, Passage.LowerPoint.Z) - Radius),
FVector(FMath::Max(Passage.UpperPoint.X, Passage.LowerPoint.X) + Radius,
FMath::Max(Passage.UpperPoint.Y, Passage.LowerPoint.Y) + Radius,
FMath::Max(Passage.UpperPoint.Z, Passage.LowerPoint.Z) + Radius)))
{
return false;
}
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ)
|| !VoxelMath::IsFinite(Landing->CeilingZ)
|| !VoxelMath::IsFinite(Landing->HalfWidth))
{
// The canonical evaluator returns FLT_MAX for this landing. Treating it as
// unknown is safer for future evaluator changes and only gives up a skip.
return false;
}
if (Landing->HalfWidth <= 0.0f
|| Landing->CeilingZ <= Landing->FloorZ)
{
continue;
}
constexpr float RoomRounding = 1.5f;
const float Height = Landing->CeilingZ - Landing->FloorZ;
const float HalfX = FMath::Max(Landing->HalfWidth - RoomRounding, 0.25f);
const float HalfZ = FMath::Max(Height * 0.5f - RoomRounding, 0.25f);
const float CenterZ = (Landing->FloorZ + Landing->CeilingZ) * 0.5f;
if (!AddDomain(
FVector(Landing->StandingPoint.X - HalfX - RoomRounding,
Landing->StandingPoint.Y - HalfX - RoomRounding,
FMath::Min(Landing->FloorZ,
CenterZ - HalfZ - RoomRounding)),
FVector(Landing->StandingPoint.X + HalfX + RoomRounding,
Landing->StandingPoint.Y + HalfX + RoomRounding,
FMath::Max(Landing->CeilingZ,
CenterZ + HalfZ + RoomRounding))))
{
return false;
}
}
}
return true;
}
static bool VF_AnyPassageModifierDomainTouchesLattice(
const TArray<FVoxelPassage>& Passages,
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step)
{
if (Step <= 0 || !VoxelBox.IsValid)
{
// An invalid query must never manufacture an identity proof.
return true;
}
// EvaluateModifierSDF smooth-mins every finite primitive in passage order. The polynomial
// smooth-min can dip below the smallest raw term by at most K/6 per combine (K=3 here).
// Build a conservative AABB for each actual tube/landing primitive, then pad the union by
// the worst finite dip. This is materially tighter than Passage.BoundRadius for a long,
// thin inter-strate route, while still being a pure reject gate: a miss proves only that
// the modifier cannot be < 4 at any MC lattice point. Malformed data remains Unknown.
constexpr float CarveThreshold = 4.0f;
constexpr float SmoothMinK = 3.0f;
TArray<FVoxelPassageModifierDomain, TInlineAllocator<128>> Domains;
if (!VF_BuildPassageModifierDomains(Passages, Domains))
{
return true;
}
if (Domains.Num() == 0)
{
return false;
}
const int64 DomainCount = Domains.Num();
const float SmoothDip = static_cast<float>(DomainCount - 1)
* (SmoothMinK / 6.0f);
const float Padding = CarveThreshold + SmoothDip;
if (!VoxelMath::IsFinite(Padding) || Padding < 0.0f)
{
return true;
}
for (const FVoxelPassageModifierDomain& Domain : Domains)
{
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Domain.Min.X - Padding, Domain.Max.X + Padding,
Domain.Min.Y - Padding, Domain.Max.Y + Padding,
Domain.Min.Z - Padding, Domain.Max.Z + Padding))
{
return true;
}
}
return false;
}
static FORCEINLINE float VF_DistanceToSegmentLowerBound(
const FVector& Position, const FVector& A, const FVector& B, float Radius)
{
const FVector AB = B - A;
const FVector AP = Position - A;
const float LenSq = FVector::DotProduct(AB, AB);
const float T = LenSq > KINDA_SMALL_NUMBER
? FMath::Clamp(FVector::DotProduct(AP, AB) / LenSq, 0.0f, 1.0f)
: 0.0f;
const FVector Closest = A + AB * T;
return FVector::Dist(Position, Closest) - Radius;
}
static bool VF_PointMayHavePassageCarve(
const TArray<FVoxelPassage>& Passages,
const FVector& Position)
{
if (!VoxelMath::IsFinite(Position.X) || !VoxelMath::IsFinite(Position.Y)
|| !VoxelMath::IsFinite(Position.Z))
{
return true;
}
constexpr float BlendK = 3.0f;
constexpr float CarveThreshold = 4.0f;
constexpr float NumericalSafetyMargin = 1.0e-3f;
float ModifierLowerBound = FLT_MAX;
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return true;
}
if (FVector::DistSquared(Position, Passage.BoundCenter) > Passage.BoundRadiusSq)
{
continue;
}
float PassageLowerBound = FLT_MAX;
if (Passage.ControlPoints.Num() >= 2)
{
if (Passage.ControlPoints.Num() > 4096)
{
return true;
}
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
if (!bTaper && !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num(); ++PointIndex)
{
const FVector& Point = Passage.ControlPoints[PointIndex];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z))
{
return true;
}
if (bTaper && !VoxelMath::IsFinite(Passage.ControlRadii[PointIndex]))
{
return true;
}
}
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float RadiusA = bTaper
? Passage.ControlRadii[SegmentIndex] : Passage.Radius;
const float RadiusB = bTaper
? Passage.ControlRadii[SegmentIndex + 1] : Passage.Radius;
const float Radius = FMath::Max(FMath::Abs(RadiusA), FMath::Abs(RadiusB));
const float SegmentLowerBound = VF_DistanceToSegmentLowerBound(
Position, A, B, Radius);
if (!VoxelMath::IsFinite(SegmentLowerBound))
{
return true;
}
PassageLowerBound = VoxelSDF::SmoothMin(
PassageLowerBound, SegmentLowerBound, BlendK);
}
}
else
{
if (!VoxelMath::IsFinite(Passage.UpperPoint.X)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Y)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Z)
|| !VoxelMath::IsFinite(Passage.LowerPoint.X)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Y)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Z)
|| !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
PassageLowerBound = VF_DistanceToSegmentLowerBound(
Position, Passage.UpperPoint, Passage.LowerPoint,
FMath::Abs(Passage.Radius));
if (!VoxelMath::IsFinite(PassageLowerBound))
{
return true;
}
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ)
|| !VoxelMath::IsFinite(Landing->CeilingZ)
|| !VoxelMath::IsFinite(Landing->HalfWidth))
{
return true;
}
if (Landing->HalfWidth <= 0.0f
|| Landing->CeilingZ <= Landing->FloorZ)
{
continue;
}
const float LandingSDF = VF_EvaluatePassageLandingSDF(Position, *Landing);
if (!VoxelMath::IsFinite(LandingSDF))
{
return true;
}
PassageLowerBound = VoxelSDF::SmoothMin(
PassageLowerBound, LandingSDF, BlendK);
}
ModifierLowerBound = VoxelSDF::SmoothMin(
ModifierLowerBound, PassageLowerBound, BlendK);
}
return !VoxelMath::IsFinite(ModifierLowerBound)
|| ModifierLowerBound < CarveThreshold + NumericalSafetyMargin;
}
static float VF_DistanceBetweenAABBs(
const FVector& MinA, const FVector& MaxA,
const FVector& MinB, const FVector& MaxB)
{
const float DX = MaxA.X < MinB.X ? MinB.X - MaxA.X
: MaxB.X < MinA.X ? MinA.X - MaxB.X : 0.0f;
const float DY = MaxA.Y < MinB.Y ? MinB.Y - MaxA.Y
: MaxB.Y < MinA.Y ? MinA.Y - MaxB.Y : 0.0f;
const float DZ = MaxA.Z < MinB.Z ? MinB.Z - MaxA.Z
: MaxB.Z < MinA.Z ? MinA.Z - MaxB.Z : 0.0f;
return FMath::Sqrt(DX * DX + DY * DY + DZ * DZ);
}
// Exact minimum distance between a finite segment and an axis-aligned box. The squared
// distance to a box is piecewise quadratic along the segment; the only breakpoints are where
// one segment coordinate crosses one of the six box planes. This is a small, allocation-free
// lower-bound primitive for the passage proof, not a change to the runtime SDF evaluator.
static bool VF_SegmentDistanceToBox(
const FVector& A, const FVector& B, const FBox& Box, float& OutDistance)
{
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y) || !VoxelMath::IsFinite(A.Z)
|| !VoxelMath::IsFinite(B.X) || !VoxelMath::IsFinite(B.Y) || !VoxelMath::IsFinite(B.Z)
|| !Box.IsValid)
{
return false;
}
const FVector D = B - A;
float Breaks[8] = { 0.0f, 1.0f };
int32 BreakCount = 2;
const float AValues[3] = { A.X, A.Y, A.Z };
const float DValues[3] = { D.X, D.Y, D.Z };
const float BoxMinValues[3] = {
(float)Box.Min.X, (float)Box.Min.Y, (float)Box.Min.Z };
const float BoxMaxValues[3] = {
(float)Box.Max.X, (float)Box.Max.Y, (float)Box.Max.Z };
for (int32 Axis = 0; Axis < 3; ++Axis)
{
// This is a lower-bound proof. A nonzero direction, however small, can cross a
// box plane and reduce the segment distance; treating it as stationary would make
// the bound too high and could incorrectly skip geometry.
if (DValues[Axis] == 0.0f)
{
continue;
}
const float TMin = (BoxMinValues[Axis] - AValues[Axis]) / DValues[Axis];
const float TMax = (BoxMaxValues[Axis] - AValues[Axis]) / DValues[Axis];
if (TMin > 0.0f && TMin < 1.0f && BreakCount < UE_ARRAY_COUNT(Breaks))
{
Breaks[BreakCount++] = TMin;
}
if (TMax > 0.0f && TMax < 1.0f && BreakCount < UE_ARRAY_COUNT(Breaks))
{
Breaks[BreakCount++] = TMax;
}
}
for (int32 I = 1; I < BreakCount; ++I)
{
const float Value = Breaks[I];
int32 J = I - 1;
while (J >= 0 && Breaks[J] > Value)
{
Breaks[J + 1] = Breaks[J];
--J;
}
Breaks[J + 1] = Value;
}
float MinimumDistanceSquared = FLT_MAX;
for (int32 Interval = 0; Interval + 1 < BreakCount; ++Interval)
{
const float T0 = Breaks[Interval];
const float T1 = Breaks[Interval + 1];
const float TM = 0.5f * (T0 + T1);
float QuadraticA = 0.0f;
float QuadraticB = 0.0f;
float QuadraticC = 0.0f;
for (int32 Axis = 0; Axis < 3; ++Axis)
{
const float Mid = AValues[Axis] + DValues[Axis] * TM;
float Offset = 0.0f;
if (Mid < BoxMinValues[Axis])
{
Offset = AValues[Axis] - BoxMinValues[Axis];
}
else if (Mid > BoxMaxValues[Axis])
{
Offset = AValues[Axis] - BoxMaxValues[Axis];
}
else
{
continue;
}
QuadraticA += DValues[Axis] * DValues[Axis];
QuadraticB += 2.0f * Offset * DValues[Axis];
QuadraticC += Offset * Offset;
}
float T = T0;
if (QuadraticA > 0.0f)
{
T = FMath::Clamp(
-QuadraticB / (2.0f * QuadraticA), T0, T1);
}
const float DistanceSquared = FMath::Max(
0.0f,
(QuadraticA * T + QuadraticB) * T + QuadraticC);
MinimumDistanceSquared = FMath::Min(
MinimumDistanceSquared, DistanceSquared);
}
if (!VoxelMath::IsFinite(MinimumDistanceSquared))
{
return false;
}
OutDistance = FMath::Sqrt(MinimumDistanceSquared);
return VoxelMath::IsFinite(OutDistance);
}
static bool VF_LandingLowerBoundOverBox(
const FVoxelPassageLanding& Landing, const FBox& Box, float& OutLowerBound)
{
if (!VoxelMath::IsFinite(Landing.StandingPoint.X)
|| !VoxelMath::IsFinite(Landing.StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing.FloorZ)
|| !VoxelMath::IsFinite(Landing.CeilingZ)
|| !VoxelMath::IsFinite(Landing.HalfWidth)
|| !Box.IsValid)
{
return false;
}
if (Landing.HalfWidth <= 0.0f || Landing.CeilingZ <= Landing.FloorZ)
{
OutLowerBound = FLT_MAX;
return true;
}
constexpr float RoomRounding = 1.5f;
const float Height = Landing.CeilingZ - Landing.FloorZ;
const FVector Center(
Landing.StandingPoint.X, Landing.StandingPoint.Y,
(Landing.FloorZ + Landing.CeilingZ) * 0.5f);
const FVector HalfExtent(
FMath::Max(Landing.HalfWidth - RoomRounding, 0.25f),
FMath::Max(Landing.HalfWidth - RoomRounding, 0.25f),
FMath::Max(Height * 0.5f - RoomRounding, 0.25f));
const FVector OuterMin = Center - HalfExtent - FVector(RoomRounding);
const FVector OuterMax = Center + HalfExtent + FVector(RoomRounding);
const FVector BoxMin((float)Box.Min.X, (float)Box.Min.Y, (float)Box.Min.Z);
const FVector BoxMax((float)Box.Max.X, (float)Box.Max.Y, (float)Box.Max.Z);
const float OuterDistance = VF_DistanceBetweenAABBs(
BoxMin, BoxMax, OuterMin, OuterMax);
const float RoundedBoxLower = OuterDistance > 0.0f
? OuterDistance
: -FMath::Max(HalfExtent.X,
FMath::Max(HalfExtent.Y, HalfExtent.Z)) - RoomRounding;
OutLowerBound = FMath::Max(
RoundedBoxLower, Landing.FloorZ - (float)Box.Max.Z);
return VoxelMath::IsFinite(OutLowerBound);
}
static bool VF_PassageModifierLowerBoundOverBox(
const TArray<FVoxelPassage>& Passages,
const FBox& Box, float& OutLowerBound)
{
if (!Box.IsValid)
{
return false;
}
constexpr float BlendK = 3.0f;
float ModifierLowerBound = FLT_MAX;
const FVector BoxMin((float)Box.Min.X, (float)Box.Min.Y, (float)Box.Min.Z);
const FVector BoxMax((float)Box.Max.X, (float)Box.Max.Y, (float)Box.Max.Z);
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return false;
}
const FVector ClosestPoint(
FMath::Clamp(Passage.BoundCenter.X, BoxMin.X, BoxMax.X),
FMath::Clamp(Passage.BoundCenter.Y, BoxMin.Y, BoxMax.Y),
FMath::Clamp(Passage.BoundCenter.Z, BoxMin.Z, BoxMax.Z));
if (FVector::DistSquared(ClosestPoint, Passage.BoundCenter)
> Passage.BoundRadiusSq)
{
continue;
}
float PassageLowerBound = FLT_MAX;
if (Passage.ControlPoints.Num() >= 2)
{
if (Passage.ControlPoints.Num() > 4096)
{
return false;
}
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
if (!bTaper && !VoxelMath::IsFinite(Passage.Radius))
{
return false;
}
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num(); ++PointIndex)
{
const FVector& Point = Passage.ControlPoints[PointIndex];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z)
|| (bTaper && !VoxelMath::IsFinite(Passage.ControlRadii[PointIndex])))
{
return false;
}
}
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const float RadiusA = bTaper
? Passage.ControlRadii[SegmentIndex] : Passage.Radius;
const float RadiusB = bTaper
? Passage.ControlRadii[SegmentIndex + 1] : Passage.Radius;
const float Radius = FMath::Max(FMath::Abs(RadiusA), FMath::Abs(RadiusB));
float SegmentDistance = 0.0f;
if (!VoxelMath::IsFinite(Radius)
|| !VF_SegmentDistanceToBox(
Passage.ControlPoints[SegmentIndex],
Passage.ControlPoints[SegmentIndex + 1], Box, SegmentDistance))
{
return false;
}
PassageLowerBound = VoxelSDF::SmoothMin(
PassageLowerBound, SegmentDistance - Radius, BlendK);
}
}
else
{
if (!VoxelMath::IsFinite(Passage.UpperPoint.X)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Y)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Z)
|| !VoxelMath::IsFinite(Passage.LowerPoint.X)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Y)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Z)
|| !VoxelMath::IsFinite(Passage.Radius))
{
return false;
}
float SegmentDistance = 0.0f;
if (!VF_SegmentDistanceToBox(
Passage.UpperPoint, Passage.LowerPoint, Box, SegmentDistance))
{
return false;
}
PassageLowerBound = SegmentDistance - FMath::Abs(Passage.Radius);
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
float LandingLowerBound = FLT_MAX;
if (!VF_LandingLowerBoundOverBox(
*Landing, Box, LandingLowerBound))
{
return false;
}
PassageLowerBound = VoxelSDF::SmoothMin(
PassageLowerBound, LandingLowerBound, BlendK);
}
ModifierLowerBound = VoxelSDF::SmoothMin(
ModifierLowerBound, PassageLowerBound, BlendK);
}
OutLowerBound = ModifierLowerBound;
return VoxelMath::IsFinite(OutLowerBound);
}
// MaxPassageCarveFactorNearLattice is queried once for the root and once for every refined
// child. The child lattice is a strict subset of the root lattice, so retaining the exact
// carve factor at each root point is a sound memo: a child reads the same values the old
// implementation would have recomputed, in the same deterministic order. The cache is
// worker-local because classifier calls can run concurrently and no mutable state may be
// published through the immutable strate manager.
struct FPassageLatticeBoundCache
{
const UVoxelStrateManager* Owner = nullptr;
uint64 OwnerLifetimeId = 0;
uint32 Version = 0xFFFFFFFFu;
FIntVector Origin = FIntVector::ZeroValue;
int32 Step = 0;
int32 FirstX = 0, LastX = -1;
int32 FirstY = 0, LastY = -1;
int32 FirstZ = 0, LastZ = -1;
bool bValid = false;
bool bNoCandidate = false;
TArray<float> Factors;
void Reset()
{
Owner = nullptr;
OwnerLifetimeId = 0;
Version = 0xFFFFFFFFu;
Origin = FIntVector::ZeroValue;
Step = 0;
FirstX = 0; LastX = -1;
FirstY = 0; LastY = -1;
FirstZ = 0; LastZ = -1;
bValid = false;
bNoCandidate = false;
Factors.Reset();
}
void Begin(const UVoxelStrateManager* InOwner, uint64 InLifetimeId,
uint32 InVersion, const FIntVector& InOrigin, int32 InStep,
int32 InFirstX, int32 InLastX,
int32 InFirstY, int32 InLastY,
int32 InFirstZ, int32 InLastZ,
bool bInNoCandidate)
{
Owner = InOwner;
OwnerLifetimeId = InLifetimeId;
Version = InVersion;
Origin = InOrigin;
Step = InStep;
FirstX = InFirstX; LastX = InLastX;
FirstY = InFirstY; LastY = InLastY;
FirstZ = InFirstZ; LastZ = InLastZ;
bValid = true;
bNoCandidate = bInNoCandidate;
Factors.Reset();
}
bool Contains(const UVoxelStrateManager* InOwner, uint64 InLifetimeId,
uint32 InVersion, const FIntVector& InOrigin, int32 InStep,
int32 InFirstX, int32 InLastX,
int32 InFirstY, int32 InLastY,
int32 InFirstZ, int32 InLastZ) const
{
return bValid && Owner == InOwner && OwnerLifetimeId == InLifetimeId
&& Version == InVersion && Origin == InOrigin && Step == InStep
&& InFirstX >= FirstX && InLastX <= LastX
&& InFirstY >= FirstY && InLastY <= LastY
&& InFirstZ >= FirstZ && InLastZ <= LastZ;
}
int32 Index(int32 IX, int32 IY, int32 IZ) const
{
const int32 DimX = LastX - FirstX + 1;
const int32 DimY = LastY - FirstY + 1;
return ((IZ - FirstZ) * DimY + (IY - FirstY)) * DimX + (IX - FirstX);
}
float MaxIn(const int32 InFirstX, const int32 InLastX,
const int32 InFirstY, const int32 InLastY,
const int32 InFirstZ, const int32 InLastZ) const
{
if (bNoCandidate) { return 0.0f; }
float Result = 0.0f;
for (int32 IZ = InFirstZ; IZ <= InLastZ; ++IZ)
{
for (int32 IY = InFirstY; IY <= InLastY; ++IY)
{
for (int32 IX = InFirstX; IX <= InLastX; ++IX)
{
Result = FMath::Max(Result, Factors[Index(IX, IY, IZ)]);
if (Result >= 1.0f)
{
return Result;
}
}
}
}
return Result;
}
};
FPassageLatticeBoundCache& VF_GetPassageLatticeBoundCache()
{
thread_local FPassageLatticeBoundCache Cache;
return Cache;
}
static bool VF_LatticeBoxTouchesAABB(
const FBox& Box, const FIntVector& Origin, int32 Step,
float MinX, float MaxX, float MinY, float MaxY, float MinZ, float MaxZ)
{
return VoxelPassageGeometry::LatticeAxisHasSampleInInterval(
FMath::Max((float)Box.Min.X, MinX),
FMath::Min((float)Box.Max.X, MaxX),
(float)Origin.X, Step)
&& VoxelPassageGeometry::LatticeAxisHasSampleInInterval(
FMath::Max((float)Box.Min.Y, MinY),
FMath::Min((float)Box.Max.Y, MaxY),
(float)Origin.Y, Step)
&& VoxelPassageGeometry::LatticeAxisHasSampleInInterval(
FMath::Max((float)Box.Min.Z, MinZ),
FMath::Min((float)Box.Max.Z, MaxZ),
(float)Origin.Z, Step);
}
static bool VF_LatticeBoxTouchesSphere(
const FBox& Box, const FVector& Center, float Radius)
{
if (!Box.IsValid || !VoxelMath::IsFinite(Center.X)
|| !VoxelMath::IsFinite(Center.Y) || !VoxelMath::IsFinite(Center.Z)
|| !VoxelMath::IsFinite(Radius) || Radius < 0.0f)
{
return true;
}
const FVector Closest(
FMath::Clamp(Center.X, (float)Box.Min.X, (float)Box.Max.X),
FMath::Clamp(Center.Y, (float)Box.Min.Y, (float)Box.Max.Y),
FMath::Clamp(Center.Z, (float)Box.Min.Z, (float)Box.Max.Z));
return FVector::DistSquared(Closest, Center) <= Radius * Radius;
}
static bool VF_WalkCorridorBodyCarveTouchesLattice(
const TArray<FVoxelPassage>& Passages,
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step)
{
if (Step <= 0 || !VoxelBox.IsValid)
{
return true;
}
constexpr float CorridorHalfWidth =
0.5f * VoxelPassageGeometry::WalkCorridorPlayerWidthVoxels
+ VoxelPassageGeometry::WalkCorridorLatticeMarginVoxels;
constexpr float CorridorBottom = VoxelPassageGeometry::MaxStepHeightVoxels;
constexpr float CorridorTop = CorridorBottom
+ VoxelPassageGeometry::WalkCorridorPlayerHeightVoxels;
for (const FVoxelPassage& Passage : Passages)
{
if (!Passage.bWalkableTunnelContract || !Passage.bNativeFloorEnabled)
{
continue;
}
float ReliefBound = 0.0f;
if (!VF_GetNativePassageFloorReliefBound(Passage, ReliefBound))
{
return true;
}
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return true;
}
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
const float FloorA = Passage.NativeFloorProfileZ[SegmentIndex];
const float FloorB = Passage.NativeFloorProfileZ[SegmentIndex + 1];
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y)
|| !VoxelMath::IsFinite(B.X) || !VoxelMath::IsFinite(B.Y)
|| !VoxelMath::IsFinite(FloorA) || !VoxelMath::IsFinite(FloorB))
{
return true;
}
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
FMath::Min(A.X, B.X) - CorridorHalfWidth,
FMath::Max(A.X, B.X) + CorridorHalfWidth,
FMath::Min(A.Y, B.Y) - CorridorHalfWidth,
FMath::Max(A.Y, B.Y) + CorridorHalfWidth,
FMath::Min(FloorA, FloorB) + CorridorBottom - ReliefBound,
FMath::Max(FloorA, FloorB) + CorridorTop + ReliefBound))
{
return true;
}
}
for (const FVoxelPassageLanding* Landing : {
&Passage.UpperLanding, &Passage.LowerLanding })
{
if (!VoxelMath::IsFinite(Landing->DoorPoint.X)
|| !VoxelMath::IsFinite(Landing->DoorPoint.Y)
|| !VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ))
{
return true;
}
const float LengthSquared = FVector2D::DistSquared(
FVector2D(Landing->DoorPoint.X, Landing->DoorPoint.Y),
FVector2D(Landing->StandingPoint.X, Landing->StandingPoint.Y));
if (!VoxelMath::IsFinite(LengthSquared))
{
return true;
}
if (LengthSquared <= KINDA_SMALL_NUMBER)
{
continue;
}
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
FMath::Min(Landing->DoorPoint.X, Landing->StandingPoint.X)
- CorridorHalfWidth,
FMath::Max(Landing->DoorPoint.X, Landing->StandingPoint.X)
+ CorridorHalfWidth,
FMath::Min(Landing->DoorPoint.Y, Landing->StandingPoint.Y)
- CorridorHalfWidth,
FMath::Max(Landing->DoorPoint.Y, Landing->StandingPoint.Y)
+ CorridorHalfWidth,
Landing->FloorZ + CorridorBottom,
Landing->FloorZ + CorridorTop))
{
return true;
}
}
}
return false;
}
}
bool UVoxelStrateManager::AnyPassageNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step) const
{
// This query feeds FPassageCarveOp::EffectOverBox, so a spatial candidate is not enough:
// returning true kills the AllSolid hypothesis even when the exact MC samples all have a
// zero carve factor. That was the LOD0 false-Mixed path. Keep the cheap domain test as the
// common reject, then use the same exact lattice factor that MaxCarveOverBox consumes. The
// manager cache makes the second call in the fold free for the same box.
const bool bBodyCarveCandidate = VF_WalkCorridorBodyCarveTouchesLattice(
Passages, VoxelBox, LatticeOrigin, Step);
if (!VF_AnyPassageModifierDomainTouchesLattice(
Passages, VoxelBox, LatticeOrigin, Step))
{
return bBodyCarveCandidate;
}
const float MaxFactor = MaxPassageCarveFactorNearLattice(
VoxelBox, LatticeOrigin, Step);
// Invalid input deliberately returns 1.0 from the exact helper. A non-finite result is also
// retained as a candidate rather than becoming an identity proof.
return !VoxelMath::IsFinite(MaxFactor) || MaxFactor > 0.0f
|| bBodyCarveCandidate;
}
bool UVoxelStrateManager::AnyPassageAirPostNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float BaseDensity, float SealThickness) const
{
// FPassageCarveOp already evaluates the complete passage modifier in the stack. The only
// passage work still outside that proof is the post-disturbance landing/tunnel-air backstop.
// Do not use the enclosing passage sphere as its candidate: that sphere is deliberately much
// wider than a walkable core and was the false-positive that made LOD0 all-solid tiles recurse.
if (Step <= 0 || !VoxelBox.IsValid
|| VoxelPassageGeometry::VerticalShaftConnectorAirMarker())
{
return true;
}
if (!VoxelMath::IsFinite(BaseDensity) || !(BaseDensity > 0.0f)
|| !VoxelMath::IsFinite(SealThickness) || SealThickness < 0.0f)
{
return true;
}
if (VF_WalkCorridorBodyCarveTouchesLattice(
Passages, VoxelBox, LatticeOrigin, Step))
{
return true;
}
int32 FirstX = 0, LastX = -1;
int32 FirstY = 0, LastY = -1;
int32 FirstZ = 0, LastZ = -1;
if (!VF_LatticeAxisRange(
VoxelBox.Min.X, VoxelBox.Max.X, (float)LatticeOrigin.X, Step, FirstX, LastX)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Y, VoxelBox.Max.Y, (float)LatticeOrigin.Y, Step, FirstY, LastY)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Z, VoxelBox.Max.Z, (float)LatticeOrigin.Z, Step, FirstZ, LastZ))
{
return true;
}
const int64 DimX = (int64)LastX - FirstX + 1;
const int64 DimY = (int64)LastY - FirstY + 1;
const int64 DimZ = (int64)LastZ - FirstZ + 1;
const int64 SampleCount = DimX * DimY * DimZ;
// This query is a proof helper, not a second unbounded density grid. An unusual external
// caller gets Unknown/candidate and therefore keeps the normal mesher path.
if (SampleCount <= 0 || SampleCount > 65536)
{
return true;
}
// The tunnel-air post is a vertical prism over the nearest horizontal control segment. Its
// existence on a lattice does not require a 3-D walk: project each XY lattice point once,
// then ask whether the resulting floor interval contains a Z lattice sample. The interval is
// deliberately closed at both ends here, so strict predicate boundaries can only create a
// false candidate; they can never hide a real air sample.
constexpr int32 MaxTunnelControlPointsForQuery = 4096;
for (const FVoxelPassage& Passage : Passages)
{
if (!Passage.bWalkableTunnelContract)
{
continue;
}
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num()
|| Passage.ControlPoints.Num() > MaxTunnelControlPointsForQuery)
{
return true;
}
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num(); ++PointIndex)
{
const FVector& Point = Passage.ControlPoints[PointIndex];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z)
|| !VoxelMath::IsFinite(Passage.ControlRadii[PointIndex]))
{
return true;
}
}
for (int32 IY = FirstY; IY <= LastY; ++IY)
{
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
for (int32 IX = FirstX; IX <= LastX; ++IX)
{
const FVector Position(
(float)LatticeOrigin.X + (float)(IX * Step), Y, 0.0f);
float FloorZ = 0.0f;
float SupportRadius = 0.0f;
if (!VoxelPassageGeometry::ProjectWalkableTunnelFloor(
Passage.ControlPoints, Passage.ControlRadii, Position,
FloorZ, SupportRadius))
{
continue;
}
const float AirMinZ = FMath::Max(
(float)VoxelBox.Min.Z,
FloorZ + VoxelPassageGeometry::WalkableTunnelFloorAirClearanceVoxels);
const float AirMaxZ = FMath::Min(
(float)VoxelBox.Max.Z,
FloorZ + 2.0f * SupportRadius);
if (VoxelPassageGeometry::LatticeAxisHasSampleInInterval(
AirMinZ, AirMaxZ,
(float)LatticeOrigin.Z, Step))
{
return true;
}
}
}
}
constexpr float LandingBlendRadius = 4.0f;
TArray<int32, TInlineAllocator<32>> Candidates;
struct FPostPotentialDomain
{
int32 PassageIndex = INDEX_NONE;
FVector Min = FVector(FLT_MAX, FLT_MAX, FLT_MAX);
FVector Max = FVector(-FLT_MAX, -FLT_MAX, -FLT_MAX);
};
TArray<FPostPotentialDomain, TInlineAllocator<64>> PotentialDomains;
float PotentialMinX = FLT_MAX;
float PotentialMinY = FLT_MAX;
float PotentialMinZ = FLT_MAX;
float PotentialMaxX = -FLT_MAX;
float PotentialMaxY = -FLT_MAX;
float PotentialMaxZ = -FLT_MAX;
// BoundCenter/BoundRadius encloses the whole passage, which is intentionally much larger
// than the post writers. Using that sphere here made every LOD0 child along a long route
// walk its complete 17^3 lattice even when the route's landing/tunnel-air AABBs were many
// chunks away. Build a conservative union of the actual post domains instead. A point
// outside these AABBs cannot satisfy either VF_EvaluatePassageLandingSDF or
// VF_IsWalkableTunnelAir; the exact predicates below still decide every point inside.
auto AddPotentialAABB = [&](int32 PassageIndex,
float MinX, float MaxX, float MinY, float MaxY,
float MinZ, float MaxZ, bool& bTouches) -> bool
{
if (!VoxelMath::IsFinite(MinX) || !VoxelMath::IsFinite(MaxX)
|| !VoxelMath::IsFinite(MinY) || !VoxelMath::IsFinite(MaxY)
|| !VoxelMath::IsFinite(MinZ) || !VoxelMath::IsFinite(MaxZ)
|| MinX > MaxX || MinY > MaxY || MinZ > MaxZ)
{
return false;
}
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
MinX, MaxX, MinY, MaxY, MinZ, MaxZ))
{
bTouches = true;
PotentialMinX = FMath::Min(PotentialMinX, MinX);
PotentialMinY = FMath::Min(PotentialMinY, MinY);
PotentialMinZ = FMath::Min(PotentialMinZ, MinZ);
PotentialMaxX = FMath::Max(PotentialMaxX, MaxX);
PotentialMaxY = FMath::Max(PotentialMaxY, MaxY);
PotentialMaxZ = FMath::Max(PotentialMaxZ, MaxZ);
PotentialDomains.Add({
PassageIndex,
FVector(MinX, MinY, MinZ), FVector(MaxX, MaxY, MaxZ) });
}
return true;
};
for (int32 PassageIndex = 0; PassageIndex < Passages.Num(); ++PassageIndex)
{
const FVoxelPassage& Passage = Passages[PassageIndex];
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return true;
}
bool bPassageTouches = false;
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
// A passage such as the optional surface entry has no landing post and therefore
// leaves this descriptor at its zero-valued default. VF_EvaluatePassageLandingSDF
// treats that descriptor as FLT_MAX (the writer is a known no-op), so it must not
// turn the whole tile into an Unknown/candidate. FloorThickness is intentionally
// not part of this validity check: the landing-air writer reads the SDF fields even
// when a separate floor descriptor is degenerate.
const bool bLandingSdfValid =
VoxelMath::IsFinite(Landing->StandingPoint.X)
&& VoxelMath::IsFinite(Landing->StandingPoint.Y)
&& VoxelMath::IsFinite(Landing->FloorZ)
&& VoxelMath::IsFinite(Landing->CeilingZ)
&& VoxelMath::IsFinite(Landing->HalfWidth)
&& Landing->HalfWidth > 0.0f
&& Landing->CeilingZ > Landing->FloorZ;
if (bLandingSdfValid)
{
const float HalfExtent = Landing->HalfWidth + LandingBlendRadius;
if (!AddPotentialAABB(
PassageIndex,
Landing->StandingPoint.X - HalfExtent,
Landing->StandingPoint.X + HalfExtent,
Landing->StandingPoint.Y - HalfExtent,
Landing->StandingPoint.Y + HalfExtent,
Landing->FloorZ - LandingBlendRadius,
Landing->CeilingZ + LandingBlendRadius,
bPassageTouches))
{
return true;
}
}
}
if (bPassageTouches)
{
Candidates.Add(PassageIndex);
}
}
if (Candidates.Num() == 0)
{
return false;
}
// The union above is conservative but can be much smaller than the queried box. Restrict the
// exact walk to its lattice intersection; a false positive still pays the exact predicates,
// while a far-away long-passage sphere does not.
if (!VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.X, PotentialMinX),
FMath::Min((float)VoxelBox.Max.X, PotentialMaxX),
(float)LatticeOrigin.X, Step, FirstX, LastX)
|| !VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Y, PotentialMinY),
FMath::Min((float)VoxelBox.Max.Y, PotentialMaxY),
(float)LatticeOrigin.Y, Step, FirstY, LastY)
|| !VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Z, PotentialMinZ),
FMath::Min((float)VoxelBox.Max.Z, PotentialMaxZ),
(float)LatticeOrigin.Z, Step, FirstZ, LastZ))
{
return false;
}
const int64 PotentialSampleCount = ((int64)LastX - FirstX + 1)
* ((int64)LastY - FirstY + 1)
* ((int64)LastZ - FirstZ + 1);
if (PotentialSampleCount <= 0 || PotentialSampleCount > 65536)
{
return true;
}
const float AirTarget = -(BaseDensity * 2.0f + SealThickness + 4.0f);
if (!VoxelMath::IsFinite(AirTarget))
{
return true;
}
for (int32 IZ = FirstZ; IZ <= LastZ; ++IZ)
{
const float Z = (float)LatticeOrigin.Z + (float)(IZ * Step);
for (int32 IY = FirstY; IY <= LastY; ++IY)
{
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
for (int32 IX = FirstX; IX <= LastX; ++IX)
{
const FVector Position(
(float)LatticeOrigin.X + (float)(IX * Step), Y, Z);
float MinLandingSDF = FLT_MAX;
for (const int32 PassageIndex : Candidates)
{
const FVoxelPassage& Passage = Passages[PassageIndex];
bool bInPotentialDomain = false;
for (const FPostPotentialDomain& Domain : PotentialDomains)
{
if (Domain.PassageIndex == PassageIndex
&& Position.X >= Domain.Min.X && Position.X <= Domain.Max.X
&& Position.Y >= Domain.Min.Y && Position.Y <= Domain.Max.Y
&& Position.Z >= Domain.Min.Z && Position.Z <= Domain.Max.Z)
{
bInPotentialDomain = true;
break;
}
}
if (!bInPotentialDomain)
{
continue;
}
const float DistanceSquared =
FVector::DistSquared(Position, Passage.BoundCenter);
if (DistanceSquared > Passage.BoundRadiusSq)
{
continue;
}
const float UpperSDF = VF_EvaluatePassageLandingSDF(
Position, Passage.UpperLanding);
const float LowerSDF = VF_EvaluatePassageLandingSDF(
Position, Passage.LowerLanding);
if (!VoxelMath::IsFinite(UpperSDF) || !VoxelMath::IsFinite(LowerSDF))
{
// A malformed landing is an unknown post, never an identity proof.
return true;
}
MinLandingSDF = FMath::Min(
MinLandingSDF, FMath::Min(UpperSDF, LowerSDF));
}
// The floor writer can only suppress a landing-air post, so omitting that
// exclusion here is deliberately conservative: it can retain a final-field
// candidate, but can never prove an empty tile that owns a support floor.
// The exact same SDF threshold as the post is sufficient for the current-density
// interpolation: SDF < 4 is exactly its activation domain.
if (MinLandingSDF < LandingBlendRadius)
{
float CarveFactor = FMath::Clamp(
(LandingBlendRadius - MinLandingSDF)
/ (LandingBlendRadius * 2.0f),
0.0f, 1.0f);
CarveFactor = SmoothStep01(CarveFactor);
const float LandingThreshold = FMath::Lerp(
BaseDensity, AirTarget, CarveFactor);
if (!VoxelMath::IsFinite(LandingThreshold)
|| LandingThreshold <= 0.0f)
{
// Zero is not solid under the mesher's sign convention, so it is part of
// the final-field risk just like a strictly air threshold.
return true;
}
}
}
}
}
return false;
}
float UVoxelStrateManager::MaxPassageCarveFactorNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step) const
{
// The passage bound is only a cheap candidate test. It encloses an entire multi-segment
// passage, so using it as the final lattice proof turns a long tunnel into a false positive
// for every tile inside its enclosing sphere. That is particularly damaging at LOD0: the
// classifier then falls through to a full density grid even when every sampled point is rock.
//
// Once a bound reaches this lattice, ask the same exact modifier SDF used by
// ApplyPassageCarvingOnly at the actual MC samples. This is still a proof, not a sampling
// shortcut: the operator is evaluated at precisely the points the mesher will evaluate, and
// a non-finite result remains conservative. The common no-candidate path stays O(P), while a
// false-positive bound pays one exact lattice walk and can then be classified as Identity.
if (Step <= 0 || !VoxelBox.IsValid)
{
return 1.0f;
}
int32 FirstX = 0, LastX = -1;
int32 FirstY = 0, LastY = -1;
int32 FirstZ = 0, LastZ = -1;
if (!VF_LatticeAxisRange(
VoxelBox.Min.X, VoxelBox.Max.X, (float)LatticeOrigin.X, Step, FirstX, LastX)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Y, VoxelBox.Max.Y, (float)LatticeOrigin.Y, Step, FirstY, LastY)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Z, VoxelBox.Max.Z, (float)LatticeOrigin.Z, Step, FirstZ, LastZ))
{
return 1.0f;
}
FPassageLatticeBoundCache& Cache = VF_GetPassageLatticeBoundCache();
const uint64 LifetimeId = GetCacheLifetimeId();
const uint32 Version = GetLayoutVersion();
if (Cache.Contains(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ))
{
return Cache.MaxIn(FirstX, LastX, FirstY, LastY, FirstZ, LastZ);
}
constexpr float PassageCarveThreshold = 4.0f;
constexpr float SmoothMinK = 3.0f;
float ModifierBoxLowerBound = 0.0f;
if (VF_PassageModifierLowerBoundOverBox(
Passages, VoxelBox, ModifierBoxLowerBound)
&& ModifierBoxLowerBound >= PassageCarveThreshold + 1.0e-3f)
{
Cache.Begin(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ,
/*bInNoCandidate*/ true);
return 0.0f;
}
TArray<FVoxelPassageModifierDomain, TInlineAllocator<128>> ModifierDomains;
bool bKnownModifierDomains = VF_BuildPassageModifierDomains(
Passages, ModifierDomains);
float ModifierDomainPadding = FLT_MAX;
bool bModifierDomainTouchesLattice = true;
if (bKnownModifierDomains)
{
if (ModifierDomains.Num() == 0)
{
bModifierDomainTouchesLattice = false;
}
else
{
const float SmoothDip = static_cast<float>(ModifierDomains.Num() - 1)
* (SmoothMinK / 6.0f);
const float Padding = PassageCarveThreshold + SmoothDip;
ModifierDomainPadding = Padding;
if (!VoxelMath::IsFinite(Padding) || Padding < 0.0f)
{
bKnownModifierDomains = false;
}
else
{
bModifierDomainTouchesLattice = false;
for (const FVoxelPassageModifierDomain& Domain : ModifierDomains)
{
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Domain.Min.X - Padding, Domain.Max.X + Padding,
Domain.Min.Y - Padding, Domain.Max.Y + Padding,
Domain.Min.Z - Padding, Domain.Max.Z + Padding))
{
bModifierDomainTouchesLattice = true;
break;
}
}
}
}
}
if (bKnownModifierDomains && !bModifierDomainTouchesLattice)
{
Cache.Begin(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ,
/*bInNoCandidate*/ true);
return 0.0f;
}
auto CarveFactorFromSDF = [](float ModifierSDF)
{
if (!(ModifierSDF < PassageCarveThreshold))
{
return 0.0f;
}
float CarveFactor = FMath::Clamp(
(PassageCarveThreshold - ModifierSDF)
/ (PassageCarveThreshold * 2.0f),
0.0f, 1.0f);
return SmoothStep01(CarveFactor);
};
// A domain hit is still much wider than the tapered capsule itself. Before paying for the
// full modifier evaluator, use a point-level lower-bound fold over the actual primitive
// domains. It preserves the saturating SmoothMin behavior, so a far segment contributes no
// artificial global K/6 penalty. This keeps the proof exact while avoiding a 33^3 walk
// through every segment for a tile that merely grazes a passage's old sphere.
const auto MayEvaluatePoint = [&](const FVector& Position) -> bool
{
if (!bKnownModifierDomains)
{
return true;
}
bool bInsideModifierDomain = false;
for (const FVoxelPassageModifierDomain& Domain : ModifierDomains)
{
if (Position.X >= Domain.Min.X - ModifierDomainPadding
&& Position.X <= Domain.Max.X + ModifierDomainPadding
&& Position.Y >= Domain.Min.Y - ModifierDomainPadding
&& Position.Y <= Domain.Max.Y + ModifierDomainPadding
&& Position.Z >= Domain.Min.Z - ModifierDomainPadding
&& Position.Z <= Domain.Max.Z + ModifierDomainPadding)
{
bInsideModifierDomain = true;
break;
}
}
return bInsideModifierDomain
&& VF_PointMayHavePassageCarve(Passages, Position);
};
// Do not sweep the complete 33^3 lattice merely because a continuous passage domain enters
// the tile. Recursively split the sample index box and use the exact segment/box lower bound
// above to discard whole groups. A leaf still evaluates only the original MC vertices; this is
// a proof acceleration, not a lower-resolution sample.
const int64 FullSampleCount =
(static_cast<int64>(LastX) - FirstX + 1)
* (static_cast<int64>(LastY) - FirstY + 1)
* (static_cast<int64>(LastZ) - FirstZ + 1);
constexpr int64 MaxRecursiveLatticeSamples = 65536;
if (bKnownModifierDomains && FullSampleCount > 0
&& FullSampleCount <= MaxRecursiveLatticeSamples)
{
Cache.Begin(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ,
/*bInNoCandidate*/ false);
Cache.Factors.SetNumZeroed(static_cast<int32>(FullSampleCount));
float MaxCarveFactor = 0.0f;
auto EvaluatePoint = [&](int32 IX, int32 IY, int32 IZ)
{
const float X = (float)LatticeOrigin.X + (float)(IX * Step);
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
const float Z = (float)LatticeOrigin.Z + (float)(IZ * Step);
const FVector Position(X, Y, Z);
if (!MayEvaluatePoint(Position))
{
return;
}
const float ModifierSDF = EvaluateModifierSDF(X, Y, Z);
const float CarveFactor = VoxelMath::IsFinite(ModifierSDF)
? CarveFactorFromSDF(ModifierSDF) : 1.0f;
Cache.Factors[Cache.Index(IX, IY, IZ)] = CarveFactor;
MaxCarveFactor = FMath::Max(MaxCarveFactor, CarveFactor);
};
auto Visit = [&](auto&& Self,
int32 IX0, int32 IX1,
int32 IY0, int32 IY1,
int32 IZ0, int32 IZ1) -> void
{
const FVector NodeMin(
(float)LatticeOrigin.X + (float)(IX0 * Step),
(float)LatticeOrigin.Y + (float)(IY0 * Step),
(float)LatticeOrigin.Z + (float)(IZ0 * Step));
const FVector NodeMax(
(float)LatticeOrigin.X + (float)(IX1 * Step),
(float)LatticeOrigin.Y + (float)(IY1 * Step),
(float)LatticeOrigin.Z + (float)(IZ1 * Step));
const FBox NodeBox(NodeMin, NodeMax);
float NodeLowerBound = 0.0f;
if (VF_PassageModifierLowerBoundOverBox(
Passages, NodeBox, NodeLowerBound)
&& NodeLowerBound >= PassageCarveThreshold + 1.0e-3f)
{
return;
}
const int64 NodeSampleCount =
(static_cast<int64>(IX1) - IX0 + 1)
* (static_cast<int64>(IY1) - IY0 + 1)
* (static_cast<int64>(IZ1) - IZ0 + 1);
if (NodeSampleCount <= 64)
{
for (int32 IZ = IZ0; IZ <= IZ1; ++IZ)
for (int32 IY = IY0; IY <= IY1; ++IY)
for (int32 IX = IX0; IX <= IX1; ++IX)
{
EvaluatePoint(IX, IY, IZ);
}
return;
}
const int32 SpanX = IX1 - IX0;
const int32 SpanY = IY1 - IY0;
const int32 SpanZ = IZ1 - IZ0;
if (SpanX >= SpanY && SpanX >= SpanZ && SpanX > 0)
{
const int32 Mid = IX0 + SpanX / 2;
Self(Self, IX0, Mid, IY0, IY1, IZ0, IZ1);
Self(Self, Mid + 1, IX1, IY0, IY1, IZ0, IZ1);
}
else if (SpanY >= SpanZ && SpanY > 0)
{
const int32 Mid = IY0 + SpanY / 2;
Self(Self, IX0, IX1, IY0, Mid, IZ0, IZ1);
Self(Self, IX0, IX1, Mid + 1, IY1, IZ0, IZ1);
}
else if (SpanZ > 0)
{
const int32 Mid = IZ0 + SpanZ / 2;
Self(Self, IX0, IX1, IY0, IY1, IZ0, Mid);
Self(Self, IX0, IX1, IY0, IY1, Mid + 1, IZ1);
}
else
{
EvaluatePoint(IX0, IY0, IZ0);
}
};
Visit(Visit, FirstX, LastX, FirstY, LastY, FirstZ, LastZ);
return MaxCarveFactor;
}
int32 EvaluationFirstX = FirstX, EvaluationLastX = LastX;
int32 EvaluationFirstY = FirstY, EvaluationLastY = LastY;
int32 EvaluationFirstZ = FirstZ, EvaluationLastZ = LastZ;
if (bKnownModifierDomains)
{
float CandidateMinX = FLT_MAX;
float CandidateMinY = FLT_MAX;
float CandidateMinZ = FLT_MAX;
float CandidateMaxX = -FLT_MAX;
float CandidateMaxY = -FLT_MAX;
float CandidateMaxZ = -FLT_MAX;
for (const FVoxelPassageModifierDomain& Domain : ModifierDomains)
{
CandidateMinX = FMath::Min(CandidateMinX,
Domain.Min.X - ModifierDomainPadding);
CandidateMinY = FMath::Min(CandidateMinY,
Domain.Min.Y - ModifierDomainPadding);
CandidateMinZ = FMath::Min(CandidateMinZ,
Domain.Min.Z - ModifierDomainPadding);
CandidateMaxX = FMath::Max(CandidateMaxX,
Domain.Max.X + ModifierDomainPadding);
CandidateMaxY = FMath::Max(CandidateMaxY,
Domain.Max.Y + ModifierDomainPadding);
CandidateMaxZ = FMath::Max(CandidateMaxZ,
Domain.Max.Z + ModifierDomainPadding);
}
if (!VoxelMath::IsFinite(CandidateMinX) || !VoxelMath::IsFinite(CandidateMinY)
|| !VoxelMath::IsFinite(CandidateMinZ) || !VoxelMath::IsFinite(CandidateMaxX)
|| !VoxelMath::IsFinite(CandidateMaxY) || !VoxelMath::IsFinite(CandidateMaxZ))
{
bKnownModifierDomains = false;
}
else if (!VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.X, CandidateMinX),
FMath::Min((float)VoxelBox.Max.X, CandidateMaxX),
(float)LatticeOrigin.X, Step,
EvaluationFirstX, EvaluationLastX)
|| !VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Y, CandidateMinY),
FMath::Min((float)VoxelBox.Max.Y, CandidateMaxY),
(float)LatticeOrigin.Y, Step,
EvaluationFirstY, EvaluationLastY)
|| !VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Z, CandidateMinZ),
FMath::Min((float)VoxelBox.Max.Z, CandidateMaxZ),
(float)LatticeOrigin.Z, Step,
EvaluationFirstZ, EvaluationLastZ))
{
Cache.Begin(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ,
/*bInNoCandidate*/ true);
return 0.0f;
}
}
const int64 DimX = static_cast<int64>(LastX) - FirstX + 1;
const int64 DimY = static_cast<int64>(LastY) - FirstY + 1;
const int64 DimZ = static_cast<int64>(LastZ) - FirstZ + 1;
const int64 SampleCount = DimX * DimY * DimZ;
constexpr int64 MaxCachedLatticeSamples = 65536;
if (SampleCount > 0 && SampleCount <= MaxCachedLatticeSamples)
{
Cache.Begin(
this, LifetimeId, Version, LatticeOrigin, Step,
FirstX, LastX, FirstY, LastY, FirstZ, LastZ,
/*bInNoCandidate*/ false);
if (bKnownModifierDomains)
{
Cache.Factors.SetNumZeroed(static_cast<int32>(SampleCount));
}
else
{
Cache.Factors.SetNumUninitialized(static_cast<int32>(SampleCount));
}
float MaxCarveFactor = 0.0f;
for (int32 IZ = EvaluationFirstZ; IZ <= EvaluationLastZ; ++IZ)
{
const float Z = (float)LatticeOrigin.Z + (float)(IZ * Step);
for (int32 IY = EvaluationFirstY; IY <= EvaluationLastY; ++IY)
{
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
for (int32 IX = EvaluationFirstX; IX <= EvaluationLastX; ++IX)
{
const float X = (float)LatticeOrigin.X + (float)(IX * Step);
const FVector Position(X, Y, Z);
float CarveFactor = 0.0f;
if (MayEvaluatePoint(Position))
{
const float ModifierSDF = EvaluateModifierSDF(X, Y, Z);
CarveFactor = VoxelMath::IsFinite(ModifierSDF)
? CarveFactorFromSDF(ModifierSDF) : 1.0f;
}
Cache.Factors[Cache.Index(IX, IY, IZ)] = CarveFactor;
MaxCarveFactor = FMath::Max(MaxCarveFactor, CarveFactor);
if (MaxCarveFactor >= 1.0f)
{
// The remaining values are still filled below. Descendant queries need
// the complete exact lattice, not merely this query's maximum.
for (int32 RemainingZ = IZ; RemainingZ <= LastZ; ++RemainingZ)
{
const float RemainingWorldZ =
(float)LatticeOrigin.Z + (float)(RemainingZ * Step);
const int32 StartY = RemainingZ == IZ ? IY : FirstY;
for (int32 RemainingY = StartY; RemainingY <= LastY; ++RemainingY)
{
const float RemainingWorldY =
(float)LatticeOrigin.Y + (float)(RemainingY * Step);
const int32 StartX =
(RemainingZ == IZ && RemainingY == IY) ? IX + 1 : FirstX;
for (int32 RemainingX = StartX; RemainingX <= LastX; ++RemainingX)
{
const float RemainingWorldX =
(float)LatticeOrigin.X + (float)(RemainingX * Step);
const FVector RemainingPosition(
RemainingWorldX, RemainingWorldY, RemainingWorldZ);
float RemainingFactor = 0.0f;
if (MayEvaluatePoint(RemainingPosition))
{
const float RemainingSDF = EvaluateModifierSDF(
RemainingWorldX, RemainingWorldY, RemainingWorldZ);
RemainingFactor = VoxelMath::IsFinite(RemainingSDF)
? CarveFactorFromSDF(RemainingSDF) : 1.0f;
}
Cache.Factors[Cache.Index(RemainingX, RemainingY, RemainingZ)] =
RemainingFactor;
}
}
}
return MaxCarveFactor;
}
}
}
}
return MaxCarveFactor;
}
// Very large or unusual external queries do not enter the bounded worker memo. Keep the
// original exact walk for them; refusing the cache must never change the proof.
Cache.Reset();
float MaxCarveFactor = 0.0f;
for (int32 IZ = EvaluationFirstZ; IZ <= EvaluationLastZ; ++IZ)
{
const float Z = (float)LatticeOrigin.Z + (float)(IZ * Step);
for (int32 IY = EvaluationFirstY; IY <= EvaluationLastY; ++IY)
{
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
for (int32 IX = EvaluationFirstX; IX <= EvaluationLastX; ++IX)
{
const float X = (float)LatticeOrigin.X + (float)(IX * Step);
const FVector Position(X, Y, Z);
if (!MayEvaluatePoint(Position))
{
continue;
}
const float ModifierSDF = EvaluateModifierSDF(X, Y, Z);
if (!VoxelMath::IsFinite(ModifierSDF))
{
return 1.0f;
}
MaxCarveFactor = FMath::Max(
MaxCarveFactor, CarveFactorFromSDF(ModifierSDF));
if (MaxCarveFactor >= 1.0f)
{
return MaxCarveFactor;
}
}
}
}
return MaxCarveFactor;
}
bool UVoxelStrateManager::AnyPassageLandingFloorNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step) const
{
if (Step <= 0 || !VoxelBox.IsValid)
{
return true;
}
for (const FVoxelPassage& Passage : Passages)
{
float ReliefBound = 0.0f;
if (!VF_GetNativePassageFloorReliefBound(Passage, ReliefBound))
{
return true;
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ)
|| !VoxelMath::IsFinite(Landing->HalfWidth)
|| !VoxelMath::IsFinite(Landing->FloorThickness))
{
return true;
}
if (Landing->HalfWidth <= 0.0f || Landing->FloorThickness <= 0.0f)
{
continue;
}
constexpr float Pad = 1.0f;
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Landing->StandingPoint.X - Landing->HalfWidth - Pad,
Landing->StandingPoint.X + Landing->HalfWidth + Pad,
Landing->StandingPoint.Y - Landing->HalfWidth - Pad,
Landing->StandingPoint.Y + Landing->HalfWidth + Pad,
Landing->FloorZ - Landing->FloorThickness - Pad,
Landing->FloorZ + Pad))
{
return true;
}
}
if (Passage.bWalkableTunnelContract)
{
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return true;
}
constexpr float Pad = 1.0f;
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y)
|| !VoxelMath::IsFinite(A.Z) || !VoxelMath::IsFinite(B.X)
|| !VoxelMath::IsFinite(B.Y) || !VoxelMath::IsFinite(B.Z)
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex])
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex + 1]))
{
return true;
}
const float RadiusA = FMath::Abs(Passage.ControlRadii[SegmentIndex]);
const float RadiusB = FMath::Abs(Passage.ControlRadii[SegmentIndex + 1]);
const float SupportRadius =
VoxelPassageGeometry::NativePassageFloorSupportRadius(RadiusA, RadiusB);
const float FloorA = Passage.bNativeFloorEnabled
? Passage.NativeFloorProfileZ[SegmentIndex]
: VoxelPassageGeometry::TunnelFloorZ(A, RadiusA);
const float FloorB = Passage.bNativeFloorEnabled
? Passage.NativeFloorProfileZ[SegmentIndex + 1]
: VoxelPassageGeometry::TunnelFloorZ(B, RadiusB);
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
FMath::Min(A.X, B.X) - SupportRadius - Pad,
FMath::Max(A.X, B.X) + SupportRadius + Pad,
FMath::Min(A.Y, B.Y) - SupportRadius - Pad,
FMath::Max(A.Y, B.Y) + SupportRadius + Pad,
FMath::Min(FloorA, FloorB)
- VoxelPassageGeometry::LandingFloorThicknessVoxels
- Pad - ReliefBound,
FMath::Max(FloorA, FloorB) + Pad + ReliefBound))
{
return true;
}
}
}
}
return false;
}
bool UVoxelStrateManager::AnyPassageLandingNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float ReachScale) const
{
if (Step <= 0 || !VoxelBox.IsValid
|| !VoxelMath::IsFinite(ReachScale) || ReachScale <= 0.0f)
{
return true;
}
// VF_ApplyPassageCarving has a hard no-op band at ModSDF >= 4. A landing term outside the
// rounded-room AABB by 4 + K (K=3) is either saturated out of SmoothMin when the tube is
// inside the carve band, or leaves the folded result >= 4 when the tube is outside it. That
// proves the landing term cannot change the field; the direct landing/floor posts use their
// smaller, operation-specific pads below.
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return true;
}
if (Passage.ControlPoints.Num() >= 2)
{
if (Passage.ControlPoints.Num() > 4096)
{
return true;
}
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
if (!bTaper && !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
for (int32 PointIndex = 0;
PointIndex < Passage.ControlPoints.Num(); ++PointIndex)
{
const FVector& Point = Passage.ControlPoints[PointIndex];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z)
|| (bTaper && !VoxelMath::IsFinite(Passage.ControlRadii[PointIndex])))
{
return true;
}
}
}
else
{
if (!VoxelMath::IsFinite(Passage.UpperPoint.X)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Y)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Z)
|| !VoxelMath::IsFinite(Passage.LowerPoint.X)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Y)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Z)
|| !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
}
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ)
|| !VoxelMath::IsFinite(Landing->CeilingZ)
|| !VoxelMath::IsFinite(Landing->HalfWidth)
|| !VoxelMath::IsFinite(Landing->FloorThickness))
{
return true;
}
if (Landing->HalfWidth > 0.0f
&& Landing->FloorThickness > 0.0f
&& VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Landing->StandingPoint.X - FMath::Max(Landing->HalfWidth - 1.0f, 0.0f)
- ReachScale,
Landing->StandingPoint.X + FMath::Max(Landing->HalfWidth - 1.0f, 0.0f)
+ ReachScale,
Landing->StandingPoint.Y - FMath::Max(Landing->HalfWidth - 1.0f, 0.0f)
- ReachScale,
Landing->StandingPoint.Y + FMath::Max(Landing->HalfWidth - 1.0f, 0.0f)
+ ReachScale,
Landing->FloorZ - Landing->FloorThickness - ReachScale,
Landing->FloorZ + ReachScale))
{
return true;
}
if (Landing->HalfWidth <= 0.0f || Landing->CeilingZ <= Landing->FloorZ)
{
// VF_EvaluatePassageLandingSDF returns FLT_MAX for this descriptor. The floor
// test above has already handled the only remaining possible writer.
continue;
}
}
}
constexpr float SmoothMinK = 3.0f;
const float RoomPad = (VoxelPassageGeometry::LandingCarveBlendVoxels + SmoothMinK)
* ReachScale;
if (!VoxelMath::IsFinite(RoomPad) || RoomPad < 0.0f)
{
return true;
}
for (const FVoxelPassage& Passage : Passages)
{
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (Landing->HalfWidth <= 0.0f || Landing->CeilingZ <= Landing->FloorZ)
{
continue;
}
constexpr float RoomRounding = 1.5f;
const float Height = Landing->CeilingZ - Landing->FloorZ;
const float HalfX = FMath::Max(Landing->HalfWidth - RoomRounding, 0.25f);
const float HalfZ = FMath::Max(Height * 0.5f - RoomRounding, 0.25f);
const float CenterZ = (Landing->FloorZ + Landing->CeilingZ) * 0.5f;
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Landing->StandingPoint.X - HalfX - RoomRounding - RoomPad,
Landing->StandingPoint.X + HalfX + RoomRounding + RoomPad,
Landing->StandingPoint.Y - HalfX - RoomRounding - RoomPad,
Landing->StandingPoint.Y + HalfX + RoomRounding + RoomPad,
FMath::Min(Landing->FloorZ,
CenterZ - HalfZ - RoomRounding) - RoomPad,
FMath::Max(Landing->CeilingZ,
CenterZ + HalfZ + RoomRounding) + RoomPad))
{
return true;
}
}
}
return false;
}
bool UVoxelStrateManager::AnyPassageCarvingNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float ReachScale) const
{
if (VoxelDensityAblation::IsPassageCarvingOff())
{
return false;
}
if (Step <= 0 || !VoxelBox.IsValid
|| !VoxelMath::IsFinite(ReachScale) || ReachScale <= 0.0f)
{
return true;
}
// BoundRadius is built around every capsule control point and both landing rooms. The
// construction already adds the ModSDF<4 carve band. SmoothMin can lower a chain of
// otherwise-far finite terms by at most K/6 per combine, so include that finite morphology
// loss as well. A miss of this sphere proves every capsule/landing term folds to the hard
// no-op band before VF_ApplyPassageCarving; malformed descriptors remain candidates.
int32 SmoothMinCombines = 0;
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return true;
}
if (Passage.ControlPoints.Num() >= 2)
{
if (Passage.ControlPoints.Num() > 4096)
{
return true;
}
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
if (!bTaper && !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
for (int32 Index = 0; Index < Passage.ControlPoints.Num(); ++Index)
{
const FVector& Point = Passage.ControlPoints[Index];
if (!VoxelMath::IsFinite(Point.X) || !VoxelMath::IsFinite(Point.Y)
|| !VoxelMath::IsFinite(Point.Z)
|| (bTaper && !VoxelMath::IsFinite(Passage.ControlRadii[Index])))
{
return true;
}
}
SmoothMinCombines += FMath::Max(Passage.ControlPoints.Num() - 2, 0);
}
else
{
if (!VoxelMath::IsFinite(Passage.UpperPoint.X)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Y)
|| !VoxelMath::IsFinite(Passage.UpperPoint.Z)
|| !VoxelMath::IsFinite(Passage.LowerPoint.X)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Y)
|| !VoxelMath::IsFinite(Passage.LowerPoint.Z)
|| !VoxelMath::IsFinite(Passage.Radius))
{
return true;
}
}
if (Passage.bNativeFloorEnabled)
{
++SmoothMinCombines; // SmoothMax is the same K/6 polynomial bound.
}
SmoothMinCombines += 3; // passage union plus its two landing terms
const FVoxelPassageLanding* Landings[] = {
&Passage.UpperLanding, &Passage.LowerLanding };
for (const FVoxelPassageLanding* Landing : Landings)
{
if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
|| !VoxelMath::IsFinite(Landing->StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing->FloorZ)
|| !VoxelMath::IsFinite(Landing->CeilingZ)
|| !VoxelMath::IsFinite(Landing->HalfWidth)
|| !VoxelMath::IsFinite(Landing->FloorThickness))
{
return true;
}
}
}
constexpr float CarveThreshold = 4.0f;
constexpr float BlendK = 3.0f;
const float MorphologyPad = CarveThreshold
+ BlendK * static_cast<float>(FMath::Max(SmoothMinCombines, 0)) / 6.0f;
if (!VoxelMath::IsFinite(MorphologyPad) || MorphologyPad < 0.0f)
{
return true;
}
for (const FVoxelPassage& Passage : Passages)
{
bool bHasTightGeometry = false;
bool bTightTouch = false;
const float PassagePad = MorphologyPad * ReachScale;
if (!VoxelMath::IsFinite(PassagePad) || PassagePad < 0.0f)
{
return true;
}
if (Passage.ControlPoints.Num() >= 2)
{
bHasTightGeometry = Passage.ControlPoints.Num() <= 4096;
const bool bTaper = Passage.ControlRadii.Num() == Passage.ControlPoints.Num();
const float MaxRadius = bTaper
? [&Passage]()
{
float Result = 0.0f;
for (const float Radius : Passage.ControlRadii)
{
Result = FMath::Max(Result, FMath::Abs(Radius));
}
return Result;
}()
: FMath::Abs(Passage.Radius);
if (!VoxelMath::IsFinite(MaxRadius))
{
return true;
}
const float SegmentPad = (MaxRadius
+ (Passage.bNativeFloorEnabled
? VoxelPassageGeometry::LandingFloorThicknessVoxels : 0.0f)
+ PassagePad);
if (!VoxelMath::IsFinite(SegmentPad))
{
return true;
}
for (int32 SegmentIndex = 0;
bHasTightGeometry && SegmentIndex + 1 < Passage.ControlPoints.Num();
++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
FMath::Min(A.X, B.X) - SegmentPad,
FMath::Max(A.X, B.X) + SegmentPad,
FMath::Min(A.Y, B.Y) - SegmentPad,
FMath::Max(A.Y, B.Y) + SegmentPad,
FMath::Min(A.Z, B.Z) - SegmentPad,
FMath::Max(A.Z, B.Z) + SegmentPad))
{
bTightTouch = true;
}
}
}
else
{
bHasTightGeometry = true;
const float SegmentPad = FMath::Abs(Passage.Radius)
+ (Passage.bNativeFloorEnabled
? VoxelPassageGeometry::LandingFloorThicknessVoxels : 0.0f)
+ PassagePad;
if (!VoxelMath::IsFinite(SegmentPad))
{
return true;
}
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
FMath::Min(Passage.UpperPoint.X, Passage.LowerPoint.X) - SegmentPad,
FMath::Max(Passage.UpperPoint.X, Passage.LowerPoint.X) + SegmentPad,
FMath::Min(Passage.UpperPoint.Y, Passage.LowerPoint.Y) - SegmentPad,
FMath::Max(Passage.UpperPoint.Y, Passage.LowerPoint.Y) + SegmentPad,
FMath::Min(Passage.UpperPoint.Z, Passage.LowerPoint.Z) - SegmentPad,
FMath::Max(Passage.UpperPoint.Z, Passage.LowerPoint.Z) + SegmentPad))
{
bTightTouch = true;
}
}
const float RoomPad = PassagePad;
for (const FVoxelPassageLanding* Landing : {
&Passage.UpperLanding, &Passage.LowerLanding })
{
if (Landing->HalfWidth <= 0.0f || Landing->CeilingZ <= Landing->FloorZ)
{
continue;
}
constexpr float RoomRounding = 1.5f;
const float Height = Landing->CeilingZ - Landing->FloorZ;
const float HalfX = FMath::Max(Landing->HalfWidth - RoomRounding, 0.25f);
const float HalfZ = FMath::Max(Height * 0.5f - RoomRounding, 0.25f);
const float CenterZ = (Landing->FloorZ + Landing->CeilingZ) * 0.5f;
if (VF_LatticeBoxTouchesAABB(
VoxelBox, LatticeOrigin, Step,
Landing->StandingPoint.X - HalfX - RoomRounding - RoomPad,
Landing->StandingPoint.X + HalfX + RoomRounding + RoomPad,
Landing->StandingPoint.Y - HalfX - RoomRounding - RoomPad,
Landing->StandingPoint.Y + HalfX + RoomRounding + RoomPad,
FMath::Min(Landing->FloorZ,
CenterZ - HalfZ - RoomRounding) - RoomPad,
FMath::Max(Landing->CeilingZ,
CenterZ + HalfZ + RoomRounding) + RoomPad))
{
bTightTouch = true;
}
}
if (bHasTightGeometry && !bTightTouch)
{
continue;
}
const float Reach = (Passage.BoundRadius + MorphologyPad) * ReachScale;
if (!VoxelMath::IsFinite(Reach)
|| VF_LatticeBoxTouchesSphere(VoxelBox, Passage.BoundCenter, Reach))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyPassageStructuralPostNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float ReachScale) const
{
(void)LatticeOrigin;
(void)Step;
if (Step <= 0 || !VoxelBox.IsValid
|| !VoxelMath::IsFinite(ReachScale) || ReachScale <= 0.0f)
{
return true;
}
// The construction-time BoundRadius encloses every tube, landing room, floor band, and its
// four-voxel carve margin. All structural writers below are subsets of that sphere, so a
// sphere/AABB miss proves identity without doing a per-sample chunk-shortlist lookup.
for (const FVoxelPassage& Passage : Passages)
{
if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Y)
|| !VoxelMath::IsFinite(Passage.BoundCenter.Z)
|| !VoxelMath::IsFinite(Passage.BoundRadius)
|| !VoxelMath::IsFinite(Passage.BoundRadiusSq)
|| Passage.BoundRadius < 0.0f || Passage.BoundRadiusSq < 0.0f)
{
return true;
}
const float Reach = (Passage.BoundRadius + 1.0f) * ReachScale;
if (!VoxelMath::IsFinite(Reach)
|| VF_LatticeBoxTouchesSphere(VoxelBox, Passage.BoundCenter, Reach))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyLandingFloorAtLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step) const
{
// This query is used only after the stack has proved AllAir. The broad floor guards above
// are intentionally padded for sound interval folding, but that padding turns a long tunnel
// or landing AABB into a false final-field candidate. Check the actual writer predicates on
// the same MC lattice before asking GetDensityAt for a certificate. Unknown inputs remain
// candidates; this function is never allowed to manufacture an empty proof.
if (Step <= 0 || !VoxelBox.IsValid
|| VoxelPassageGeometry::VerticalShaftConnectorAirMarker())
{
return true;
}
const bool bBroadPassageFloor = AnyPassageLandingFloorNearLattice(
VoxelBox, LatticeOrigin, Step);
const bool bBroadOriginFloor = AnyOriginLandingFloorNearLattice(
VoxelBox, LatticeOrigin, Step);
if (!bBroadPassageFloor && !bBroadOriginFloor)
{
return false;
}
auto GetRange = [&](float Min, float Max, int32& OutFirst, int32& OutLast) -> bool
{
return VF_LatticeAxisRange(
Min, Max, static_cast<float>(LatticeOrigin.X), Step, OutFirst, OutLast);
};
auto GetYRange = [&](float Min, float Max, int32& OutFirst, int32& OutLast) -> bool
{
return VF_LatticeAxisRange(
Min, Max, static_cast<float>(LatticeOrigin.Y), Step, OutFirst, OutLast);
};
auto GetZRange = [&](float Min, float Max, int32& OutFirst, int32& OutLast) -> bool
{
return VF_LatticeAxisRange(
Min, Max, static_cast<float>(LatticeOrigin.Z), Step, OutFirst, OutLast);
};
auto HasAnyLandingSample = [&](const FVoxelPassageLanding& Landing) -> bool
{
if (!VoxelMath::IsFinite(Landing.StandingPoint.X)
|| !VoxelMath::IsFinite(Landing.StandingPoint.Y)
|| !VoxelMath::IsFinite(Landing.FloorZ)
|| !VoxelMath::IsFinite(Landing.HalfWidth)
|| !VoxelMath::IsFinite(Landing.FloorThickness)
|| Landing.HalfWidth <= 0.0f || Landing.FloorThickness <= 0.0f)
{
// This function gates an AllAir proof. Invalid authored floor data is an unknown
// structural writer, not evidence that the writer is absent.
return true;
}
const float HalfWidth = FMath::Max(Landing.HalfWidth - 1.0f, 0.0f);
int32 IX0 = 0, IX1 = -1, IY0 = 0, IY1 = -1, IZ0 = 0, IZ1 = -1;
return VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.X,
Landing.StandingPoint.X - HalfWidth),
FMath::Min((float)VoxelBox.Max.X,
Landing.StandingPoint.X + HalfWidth),
(float)LatticeOrigin.X, Step, IX0, IX1)
&& VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Y,
Landing.StandingPoint.Y - HalfWidth),
FMath::Min((float)VoxelBox.Max.Y,
Landing.StandingPoint.Y + HalfWidth),
(float)LatticeOrigin.Y, Step, IY0, IY1)
&& VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Z,
Landing.FloorZ - Landing.FloorThickness),
FMath::Min((float)VoxelBox.Max.Z,
Landing.FloorZ + KINDA_SMALL_NUMBER),
(float)LatticeOrigin.Z, Step, IZ0, IZ1);
};
if (bBroadPassageFloor)
{
for (const FVoxelPassage& Passage : Passages)
{
if (HasAnyLandingSample(Passage.UpperLanding)
|| HasAnyLandingSample(Passage.LowerLanding))
{
return true;
}
if (!Passage.bWalkableTunnelContract)
{
continue;
}
if (Passage.ControlPoints.Num() < 2
|| Passage.ControlRadii.Num() != Passage.ControlPoints.Num())
{
return true;
}
constexpr float Pad = 1.0f;
for (int32 SegmentIndex = 0;
SegmentIndex + 1 < Passage.ControlPoints.Num(); ++SegmentIndex)
{
const FVector& A = Passage.ControlPoints[SegmentIndex];
const FVector& B = Passage.ControlPoints[SegmentIndex + 1];
if (!VoxelMath::IsFinite(A.X) || !VoxelMath::IsFinite(A.Y)
|| !VoxelMath::IsFinite(A.Z) || !VoxelMath::IsFinite(B.X)
|| !VoxelMath::IsFinite(B.Y) || !VoxelMath::IsFinite(B.Z)
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex])
|| !VoxelMath::IsFinite(Passage.ControlRadii[SegmentIndex + 1]))
{
return true;
}
const float SupportRadius = FMath::Max(
FMath::Min(
FMath::Abs(Passage.ControlRadii[SegmentIndex]),
FMath::Abs(Passage.ControlRadii[SegmentIndex + 1])) - 0.5f,
VoxelPassageGeometry::PlayerRadiusVoxels);
const float FloorA = VoxelPassageGeometry::TunnelFloorZ(
A, Passage.ControlRadii[SegmentIndex]);
const float FloorB = VoxelPassageGeometry::TunnelFloorZ(
B, Passage.ControlRadii[SegmentIndex + 1]);
const float MinX = FMath::Min(A.X, B.X) - SupportRadius - Pad;
const float MaxX = FMath::Max(A.X, B.X) + SupportRadius + Pad;
const float MinY = FMath::Min(A.Y, B.Y) - SupportRadius - Pad;
const float MaxY = FMath::Max(A.Y, B.Y) + SupportRadius + Pad;
const float MinZ = FMath::Min(FloorA, FloorB)
- VoxelPassageGeometry::LandingFloorThicknessVoxels - Pad;
const float MaxZ = FMath::Max(FloorA, FloorB) + Pad;
if (!VoxelMath::IsFinite(MinX) || !VoxelMath::IsFinite(MaxX)
|| !VoxelMath::IsFinite(MinY) || !VoxelMath::IsFinite(MaxY)
|| !VoxelMath::IsFinite(MinZ) || !VoxelMath::IsFinite(MaxZ))
{
return true;
}
int32 IX0 = 0, IX1 = -1, IY0 = 0, IY1 = -1, IZ0 = 0, IZ1 = -1;
if (!GetRange(FMath::Max((float)VoxelBox.Min.X, MinX),
FMath::Min((float)VoxelBox.Max.X, MaxX), IX0, IX1)
|| !GetYRange(FMath::Max((float)VoxelBox.Min.Y, MinY),
FMath::Min((float)VoxelBox.Max.Y, MaxY), IY0, IY1)
|| !GetZRange(FMath::Max((float)VoxelBox.Min.Z, MinZ),
FMath::Min((float)VoxelBox.Max.Z, MaxZ), IZ0, IZ1))
{
continue;
}
for (int32 IZ = IZ0; IZ <= IZ1; ++IZ)
{
const float Z = (float)LatticeOrigin.Z + (float)(IZ * Step);
for (int32 IY = IY0; IY <= IY1; ++IY)
{
const float Y = (float)LatticeOrigin.Y + (float)(IY * Step);
for (int32 IX = IX0; IX <= IX1; ++IX)
{
const FVector Position(
(float)LatticeOrigin.X + (float)(IX * Step), Y, Z);
if (VF_IsWalkableTunnelFloor(Passage, Position))
{
return true;
}
}
}
}
}
}
}
if (bBroadOriginFloor)
{
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr) continue;
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
const VoxelPassageGeometry::FOriginLandingGeometry Geometry =
VoxelPassageGeometry::BuildOriginLandingGeometry(
TopZ, BottomZ, Seal, OriginSpineRadius);
if (!Geometry.bValid)
{
continue;
}
const float HalfWidth = FMath::Max(Geometry.HalfWidth - 1.0f, 0.0f);
int32 IX0 = 0, IX1 = -1, IY0 = 0, IY1 = -1, IZ0 = 0, IZ1 = -1;
if (VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.X, -HalfWidth - 0.0f),
FMath::Min((float)VoxelBox.Max.X, HalfWidth + 0.0f),
(float)LatticeOrigin.X, Step, IX0, IX1)
&& VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Y, -HalfWidth - 0.0f),
FMath::Min((float)VoxelBox.Max.Y, HalfWidth + 0.0f),
(float)LatticeOrigin.Y, Step, IY0, IY1)
&& VF_LatticeAxisRange(
FMath::Max((float)VoxelBox.Min.Z,
Geometry.FloorZ - Geometry.FloorThickness),
FMath::Min((float)VoxelBox.Max.Z,
Geometry.FloorZ + KINDA_SMALL_NUMBER),
(float)LatticeOrigin.Z, Step, IZ0, IZ1))
{
return true;
}
}
}
return false;
}
bool UVoxelStrateManager::AnyOriginLandingNearBox(
const FVector& MinVoxel, const FVector& MaxVoxel) const
{
if (OriginSpineRadius <= 0.0f) return false;
const FBox VoxelBox(MinVoxel, MaxVoxel);
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr) continue;
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
if (VoxelPassageGeometry::OriginLandingRoomTouchesBox(
VoxelBox, TopZ, BottomZ,
VF_BoundarySealThicknessForDefinition(*Slot.Definition),
OriginSpineRadius))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyOriginLandingFloorNearBox(
const FVector& MinVoxel, const FVector& MaxVoxel) const
{
if (OriginSpineRadius <= 0.0f) return false;
const FBox VoxelBox(MinVoxel, MaxVoxel);
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr) continue;
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
if (VoxelPassageGeometry::OriginLandingFloorTouchesBox(
VoxelBox, TopZ, BottomZ,
VF_BoundarySealThicknessForDefinition(*Slot.Definition),
OriginSpineRadius))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyOriginLandingNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float ReachScale) const
{
if (OriginSpineRadius <= 0.0f) return false;
if (!VoxelMath::IsFinite(ReachScale) || ReachScale <= 0.0f)
{
return true;
}
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr) continue;
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
if (VoxelPassageGeometry::OriginLandingRoomTouchesLattice(
VoxelBox, LatticeOrigin, Step, TopZ, BottomZ, Seal, OriginSpineRadius,
ReachScale))
{
return true;
}
}
return false;
}
bool UVoxelStrateManager::AnyOriginLandingAirNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step,
float BaseDensity, float SealThickness) const
{
if (Step <= 0 || !VoxelBox.IsValid || OriginSpineRadius <= 0.0f)
{
return true;
}
if (!VoxelMath::IsFinite(BaseDensity) || !(BaseDensity > 0.0f)
|| !VoxelMath::IsFinite(SealThickness) || SealThickness < 0.0f)
{
return true;
}
const float AirTarget = -(BaseDensity * 2.0f + SealThickness + 4.0f);
if (!VoxelMath::IsFinite(AirTarget))
{
return true;
}
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr)
{
continue;
}
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
const VoxelPassageGeometry::FOriginLandingGeometry Geometry =
VoxelPassageGeometry::BuildOriginLandingGeometry(
TopZ, BottomZ, Seal, OriginSpineRadius);
if (!Geometry.bValid)
{
continue;
}
if (!VoxelPassageGeometry::OriginLandingRoomTouchesLattice(
VoxelBox, LatticeOrigin, Step, TopZ, BottomZ, Seal, OriginSpineRadius))
{
continue;
}
int32 FirstX = 0, LastX = -1;
int32 FirstY = 0, LastY = -1;
int32 FirstZ = 0, LastZ = -1;
if (!VF_LatticeAxisRange(
VoxelBox.Min.X, VoxelBox.Max.X, (float)LatticeOrigin.X, Step, FirstX, LastX)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Y, VoxelBox.Max.Y, (float)LatticeOrigin.Y, Step, FirstY, LastY)
|| !VF_LatticeAxisRange(
VoxelBox.Min.Z, VoxelBox.Max.Z, (float)LatticeOrigin.Z, Step, FirstZ, LastZ))
{
return true;
}
const int64 SampleCount = ((int64)LastX - FirstX + 1)
* ((int64)LastY - FirstY + 1)
* ((int64)LastZ - FirstZ + 1);
if (SampleCount <= 0 || SampleCount > 65536)
{
return true;
}
for (int32 IZ = FirstZ; IZ <= LastZ; ++IZ)
for (int32 IY = FirstY; IY <= LastY; ++IY)
for (int32 IX = FirstX; IX <= LastX; ++IX)
{
const FVector Position(
(float)LatticeOrigin.X + (float)(IX * Step),
(float)LatticeOrigin.Y + (float)(IY * Step),
(float)LatticeOrigin.Z + (float)(IZ * Step));
const float RoomSDF = VoxelPassageGeometry::OriginLandingRoomSDF(
Position, Geometry);
if (!VoxelMath::IsFinite(RoomSDF))
{
return true;
}
if (RoomSDF < VoxelPassageGeometry::LandingCarveBlendVoxels)
{
float CarveFactor = FMath::Clamp(
(VoxelPassageGeometry::LandingCarveBlendVoxels - RoomSDF)
/ (VoxelPassageGeometry::LandingCarveBlendVoxels * 2.0f),
0.0f, 1.0f);
CarveFactor = SmoothStep01(CarveFactor);
const float LandingThreshold = FMath::Lerp(
BaseDensity, AirTarget, CarveFactor);
if (!VoxelMath::IsFinite(LandingThreshold)
|| LandingThreshold <= 0.0f)
{
return true;
}
}
}
}
return false;
}
bool UVoxelStrateManager::AnyOriginLandingFloorNearLattice(
const FBox& VoxelBox, const FIntVector& LatticeOrigin, int32 Step) const
{
if (OriginSpineRadius <= 0.0f) return false;
for (const FStrateSlot& Slot : StrateLayout)
{
if (Slot.Definition == nullptr) continue;
const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * CHUNK_SIZE;
const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * CHUNK_SIZE;
const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
if (VoxelPassageGeometry::OriginLandingFloorTouchesLattice(
VoxelBox, LatticeOrigin, Step, TopZ, BottomZ, Seal, OriginSpineRadius))
{
return true;
}
}
return false;
}
//=============================================================================
// QUERIES
//=============================================================================
int32 UVoxelStrateManager::FindSlotIndexForChunkZ(int32 ChunkZ) const
{
// Linear search through strate layout.
// With ~10-20 strates this is fine. If we ever have hundreds,
// switch to binary search (layout is sorted by Z).
for (int32 i = 0; i < StrateLayout.Num(); i++)
{
const FStrateSlot& Slot = StrateLayout[i];
if (ChunkZ <= Slot.TopChunkZ && ChunkZ >= Slot.BottomChunkZ)
{
return i;
}
}
return -1;
}
UVoxelStrateDefinition* UVoxelStrateManager::GetStrateAt(float WorldZ) const
{
// Convert world Z to chunk Z coordinate
int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / CHUNK_SIZE);
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
if (SlotIdx >= 0)
{
return StrateLayout[SlotIdx].Definition;
}
return nullptr;
}
int32 UVoxelStrateManager::GetStrateIndex(float WorldZ) const
{
int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / CHUNK_SIZE);
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
if (SlotIdx >= 0)
{
return StrateLayout[SlotIdx].StrateIndex;
}
return -1;
}
UVoxelStrateDefinition* UVoxelStrateManager::GetStrateForChunk(const FIntVector& ChunkCoord) const
{
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx >= 0)
{
return StrateLayout[SlotIdx].Definition;
}
return nullptr;
}
bool UVoxelStrateManager::GetStrateChunkZBounds(int32 ChunkZ, int32& OutTopChunkZ, int32& OutBottomChunkZ) const
{
// Strate-aware vertical streaming. Returns the chunk-Z span of the strate containing
// ChunkZ; false if ChunkZ is in the inter-strate gap (or outside the layout) — there the
// caller leaves the vertical view UNCLAMPED, since the gap is a brief see-both-sides
// descent transition. TopChunkZ > BottomChunkZ (Z decreases downward).
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
if (SlotIdx < 0)
{
return false;
}
OutTopChunkZ = StrateLayout[SlotIdx].TopChunkZ;
OutBottomChunkZ = StrateLayout[SlotIdx].BottomChunkZ;
return true;
}
ECaveGeneratorType UVoxelStrateManager::GetGeneratorTypeForChunk(const FIntVector& ChunkCoord) const
{
// Look up which slot this chunk falls into.
// If outside all strates (above or below), default to TunnelNetwork —
// the fallback density path will produce solid rock anyway.
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
return ECaveGeneratorType::TunnelNetwork;
}
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(StrateLayout[SlotIdx].StrateIndex))
{
return Override->Archetype;
}
#endif
if (SeasonStrates.IsValidIndex(SlotIdx))
{
return SeasonStrates[SlotIdx].Archetype;
}
return StrateLayout[SlotIdx].Definition->GeneratorType;
}
bool UVoxelStrateManager::UsesOperatorStackForChunk(const FIntVector& ChunkCoord) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition) { return false; }
if (SeasonStrates.IsValidIndex(SlotIdx))
{
// A recipe is an explicit stack opt-in. Native fixed entries retain the authored/switch
// route while still reading their season parameter vector.
return SeasonStrates[SlotIdx].bUsesRecipe;
}
#if WITH_EDITOR
if (FindComposerOverride(StrateLayout[SlotIdx].StrateIndex) != nullptr)
{
// Temporary composer candidates are measured through the stack path. Do not inherit an
// unrelated asset flag from the slot being replaced.
return true;
}
#endif
const UVoxelStrateDefinition* Def = StrateLayout[SlotIdx].Definition;
if (!Def->bUseOperatorStack) { return false; }
// LA LISTE DES ARCHÉTYPES PORTÉS — le seul endroit où elle est écrite. Un archétype non porté
// ignore le drapeau et retombe sur le `switch`, pour qu'on puisse cocher la case sur n'importe
// quelle strate sans rien casser en attendant son portage.
// THE PORTED-ARCHETYPE LIST, written down exactly once. An unported archetype ignores the flag
// and falls back to the switch, so the box can be ticked anywhere without breaking anything.
switch (Def->GeneratorType)
{
case ECaveGeneratorType::Maze: return true;
case ECaveGeneratorType::FlatPlain: // les deux partagent
case ECaveGeneratorType::CrystalChamber: return true; // UNE seule pile (BuildSlabStack)
case ECaveGeneratorType::SurfaceWorld:
// Pas de garde « pas de biomes » : le combiner `Mask` existe, donc une strate à biomes
// mélange bien ses hauteurs comme le chemin d'origine.
// No no-biome guard: the Mask combiner exists, so a biome strate blends its heights
// exactly as the original path does.
return true;
case ECaveGeneratorType::VerticalShafts: return true; // 3 ops repris de Maze tels quels
case ECaveGeneratorType::FloatingIslands:
// La pile qui tourne à l'ENVERS : source de VIDE + fill, au lieu de source de ROC
// + carve, avec les MÊMES opérateurs au signe près.
return true;
case ECaveGeneratorType::Underwater:
// ⚠️ AUCUNE PILE À ELLE : `Underwater` EST `TunnelNetwork` plus un drapeau d'eau consommé
// côté rendu. `GetDensityAt` les met dans le même `case`, et `WaterLevelRelative` n'est lu
// que par `GetWaterLevel*` de ce manager — jamais par la densité (vérifié, pas supposé).
case ECaveGeneratorType::TunnelNetwork:
// Le plus gros : squelette SDF → douze modificateurs de détail → override d'op par salle,
// 19 opérateurs, dont `FRoomGraphSource` qui **APPELLE** `BuildChunkCache`/`EvaluateSDFCached`
// au lieu de les transcrire — c'est là que vit la discipline d'invariance de fenêtre
// d'ARCHITECTURE §8.4 ; en forker une copie la casserait.
//
// **8 SUR 8.** Le `switch` d'archétypes a un jumeau en pile d'opérateurs, opt-in par
// strate, chacun vérifié par un test d'équivalence bit à bit contre sa fonction d'origine.
return true;
default: return false;
}
}
bool UVoxelStrateManager::IsGapChunk(const FIntVector& ChunkCoord) const
{
if (StrateLayout.Num() == 0) return false;
// Above the top strate or below the bottom strate = open air, NOT a gap.
const int32 StackTop = StrateLayout[0].TopChunkZ;
const int32 StackBottom = StrateLayout.Last().BottomChunkZ;
if (ChunkCoord.Z > StackTop || ChunkCoord.Z < StackBottom) return false;
// Inside the stack's Z span but not in any strate slot → it's a bedrock gap.
return FindSlotIndexForChunkZ(ChunkCoord.Z) < 0;
}
FSlabGenerationParams UVoxelStrateManager::GetSlabParamsForChunk(const FIntVector& ChunkCoord) const
{
// Fallback: empty params with BaseDensity < 0 → all-air outside strate range.
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
FSlabGenerationParams Empty;
Empty.BaseDensity = -1.0f;
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
// Copy the designer-authored slab params from the strate definition, unless an editor
// composer candidate owns this slot.
FSlabGenerationParams Result;
if (SeasonStrates.IsValidIndex(SlotIdx))
{
Result = SeasonStrates[SlotIdx].Params.SlabParams;
}
#if WITH_EDITOR
else if (const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(Slot.StrateIndex))
{
Result = (Override->Archetype == ECaveGeneratorType::FlatPlain
|| Override->Archetype == ECaveGeneratorType::CrystalChamber)
? Override->Params.SlabParams
: Slot.Definition->SlabParams;
}
else
#endif
{
Result = Slot.Definition->SlabParams;
}
// Fill in the runtime Z bounds (voxel coordinates, same convention as
// FStrateGenerationParams::StrateTopWorldZ / StrateBottomWorldZ).
// TopChunkZ+1 because the top chunk's CEILING is at (TopChunkZ+1)*CHUNK_SIZE.
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)(Slot.BottomChunkZ) * CHUNK_SIZE;
return Result;
}
//=============================================================================
// PER-ARCHETYPE PARAM GETTERS
//=============================================================================
// Each mirrors GetSlabParamsForChunk: copy designer params, fill runtime Z bounds.
// No cross-boundary blending — archetypes meet at Hard boundaries.
FMazeGenerationParams UVoxelStrateManager::GetMazeParamsForChunk(const FIntVector& ChunkCoord) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
FMazeGenerationParams Empty;
Empty.BaseDensity = -1.0f;
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
FMazeGenerationParams Result = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.MazeParams : Slot.Definition->MazeParams;
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override = FindComposerOverride(Slot.StrateIndex))
{
if (Override->Archetype == ECaveGeneratorType::Maze)
{
Result = Override->Params.MazeParams;
}
}
#endif
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
return Result;
}
FSurfaceGenerationParams UVoxelStrateManager::GetSurfaceParamsForChunk(const FIntVector& ChunkCoord) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
FSurfaceGenerationParams Empty;
Empty.BaseDensity = -1.0f;
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
FSurfaceGenerationParams Result = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.SurfaceParams : Slot.Definition->SurfaceParams;
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override = FindComposerOverride(Slot.StrateIndex))
{
if (Override->Archetype == ECaveGeneratorType::SurfaceWorld)
{
Result = Override->Params.SurfaceParams;
}
}
#endif
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
return Result;
}
FVerticalShaftParams UVoxelStrateManager::GetVerticalShaftParamsForChunk(const FIntVector& ChunkCoord) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
FVerticalShaftParams Empty;
Empty.BaseDensity = -1.0f;
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
FVerticalShaftParams Result = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.VerticalShaftParams : Slot.Definition->VerticalShaftParams;
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override = FindComposerOverride(Slot.StrateIndex))
{
if (Override->Archetype == ECaveGeneratorType::VerticalShafts)
{
Result = Override->Params.VerticalShaftParams;
}
}
#endif
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
return Result;
}
FFloatingIslandParams UVoxelStrateManager::GetFloatingIslandParamsForChunk(const FIntVector& ChunkCoord) const
{
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
FFloatingIslandParams Empty;
Empty.BaseDensity = -1.0f;
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
FFloatingIslandParams Result = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.FloatingIslandParams : Slot.Definition->FloatingIslandParams;
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override = FindComposerOverride(Slot.StrateIndex))
{
if (Override->Archetype == ECaveGeneratorType::FloatingIslands)
{
Result = Override->Params.FloatingIslandParams;
}
}
#endif
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
return Result;
}
FBiomeContext UVoxelStrateManager::GetBiomeContextForChunk(const FIntVector& ChunkCoord) const
{
FBiomeContext Out;
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition) return Out;
const UVoxelStrateDefinition* Def = StrateLayout[SlotIdx].Definition;
if (Def->Biomes.Num() == 0) return Out; // biomes disabled for this strate
Out.Map = Def->BiomeMapParams;
Out.Biomes.Reserve(Def->Biomes.Num());
for (int32 i = 0; i < Def->Biomes.Num(); ++i)
{
const UVoxelBiomeDefinition* B = Def->Biomes[i];
if (!B) continue; // skip null entries (keep original index for content lookup)
FBiomeResolved R;
R.Index = i;
R.ReliefMin = B->ReliefMin; R.ReliefMax = B->ReliefMax;
R.MoistureMin = B->MoistureMin; R.MoistureMax = B->MoistureMax;
R.DebugColor = B->DebugColor.ToFColor(true);
R.MaterialPaletteIndex = B->MaterialPaletteIndex;
Out.Biomes.Add(R);
}
return Out;
}
bool UVoxelStrateManager::GetStrateUnrealZRange(float WorldZ, float& OutTopZ, float& OutBottomZ) const
{
const int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / CHUNK_SIZE);
const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
if (SlotIdx < 0) return false;
const FStrateSlot& Slot = StrateLayout[SlotIdx];
// Voxel-space Z bounds → Unreal units. Ceiling = top chunk's upper edge.
OutTopZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE * VOXEL_SIZE;
OutBottomZ = (float)(Slot.BottomChunkZ) * CHUNK_SIZE * VOXEL_SIZE;
return true;
}
FStrateDisturbanceParams UVoxelStrateManager::GetDisturbanceParamsForChunk(const FIntVector& ChunkCoord) const
{
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition)
{
return FStrateDisturbanceParams(); // all features disabled
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
FStrateDisturbanceParams Result = Slot.Definition->Disturbances;
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)(Slot.BottomChunkZ) * CHUNK_SIZE;
return Result;
}
float UVoxelStrateManager::GetWaterLevelWorldZForChunk(const FIntVector& ChunkCoord) const
{
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
if (SlotIdx < 0 || !StrateLayout[SlotIdx].Definition) return -FLT_MAX;
const FStrateSlot& Slot = StrateLayout[SlotIdx];
const UVoxelStrateDefinition* Def = Slot.Definition;
if (!Def->bHasWater) return -FLT_MAX;
// Pull the relative level from whichever archetype owns water.
float Rel = 0.0f;
const ECaveGeneratorType Archetype = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Archetype : Def->GeneratorType;
switch (Archetype)
{
case ECaveGeneratorType::SurfaceWorld:
Rel = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.SurfaceParams.WaterLevelRelative
: Def->SurfaceParams.WaterLevelRelative;
break;
default:
Rel = SeasonStrates.IsValidIndex(SlotIdx)
? SeasonStrates[SlotIdx].Params.TunnelNetworkParams.WaterLevelRelative
: Def->GenerationParams.WaterLevelRelative;
break;
}
if (Rel <= 0.0f) return -FLT_MAX;
const float BottomZ = (float)(Slot.BottomChunkZ) * CHUNK_SIZE;
const float TopZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
return FMath::Lerp(BottomZ, TopZ, FMath::Clamp(Rel, 0.0f, 1.0f));
}
FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVector& ChunkCoord) const
{
int32 SlotIdx = FindSlotIndexForChunkZ(ChunkCoord.Z);
// If outside all strates, return negative density → guaranteed air.
// BaseDensity must be < 0 because IsoLevel is 0.0 and density >= IsoLevel = solid.
if (SlotIdx < 0)
{
FStrateGenerationParams Empty;
Empty.BaseDensity = -1.0f; // Negative → air after negation
Empty.WormStrength = 0.0f;
Empty.RoomDensity = 0.0f; // No rooms outside strates
return Empty;
}
const FStrateSlot& Slot = StrateLayout[SlotIdx];
// This is the one final resolution gate for the asset-owned worm switch. It is deliberately
// applied after composer/season replacements and after boundary blending: a disabled current
// strate can never be re-enabled by a rolled candidate or by an enabled neighbour.
const auto ResolveFinalParams = [&Slot](FStrateGenerationParams Result)
{
if (VF_WormsForceOff()
|| (Slot.Definition != nullptr && !Slot.Definition->bEnableWorms))
{
Result.WormStrength = 0.0f;
}
Result = VF_ApplyRuntimeRoughnessOverrides(Result);
if (VoxelDensityAblation::IsCaveWarpOff())
{
Result.CaveWarpStrength = 0.0f;
}
return Result;
};
#if WITH_EDITOR
if (const FVoxelStrateComposerSlotOverride* Override =
FindComposerOverride(Slot.StrateIndex))
{
FStrateGenerationParams Result = Override->Params.TunnelNetworkParams;
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
// A candidate is a hard replacement of this slot. Do not blend its rolled vector with an
// authored neighbour at a boundary; this is also how the offline fixture measures it.
return ResolveFinalParams(Result);
}
#endif
if (SeasonStrates.IsValidIndex(SlotIdx))
{
FStrateGenerationParams Result = SeasonStrates[SlotIdx].Params.TunnelNetworkParams;
Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
// Season vectors are already final, measured slot records. Vertical structural posts own
// their boundary; blending them with another selected recipe would describe neither one.
return ResolveFinalParams(Result);
}
FStrateGenerationParams BaseParams = BuildParamsFromDefinition(Slot.Definition);
//=========================================================================
// SET STRATE BOUNDARY Z VALUES
//=========================================================================
// The density function needs to know the strate's Z range (in voxel coords)
// to seal the top and bottom with solid rock. This prevents caves from
// carving through strate boundaries.
//
// TopChunkZ=0, CHUNK_SIZE=32: top of the strate = chunk 0's top edge = voxel Z=32
// BottomChunkZ=-3: bottom of the strate = chunk -3's bottom edge = voxel Z=-3*32 = -96
BaseParams.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * CHUNK_SIZE;
BaseParams.StrateBottomWorldZ = (float)(Slot.BottomChunkZ) * CHUNK_SIZE;
//=========================================================================
// BOUNDARY BLENDING (transition-type aware)
//=========================================================================
// If this chunk is near a strate boundary, apply the appropriate transition
// based on the UPPER strate's TransitionType setting.
//
// Three transition styles:
//
// GRADIENT (default):
// Classic linear lerp of all params across TransitionBlendChunks. Smooth,
// invisible boundary. Cave shape morphs gradually from one strate
// to the next over several chunks.
//
// HARD:
// No blending at all — params switch instantly at the boundary.
// The abrupt change in density, room size, roughness, etc. creates
// a natural cliff, ledge, or visible material discontinuity.
// TransitionBlendChunks is ignored (effectively 0).
//
// INTERLEAVED:
// 3D Perlin noise warps the effective boundary Z position per XY column.
// Some columns transition early (fingers of the lower strate reach UP),
// others late (fingers of the upper strate reach DOWN). The Z frequency
// is intentionally low so the fingers are horizontal — wide, flat
// intrusions rather than vertical spikes.
//
// WHICH STRATE'S TRANSITION TYPE IS USED:
// At the bottom boundary of strate N (between N and N+1), we use
// strate N's (the upper strate's) TransitionType. This is consistent:
// each strate definition controls what happens at its lower edge.
// At the top boundary of strate N (between N-1 and N), we use
// strate N-1's TransitionType (the strate above controls its lower edge).
//---------------------------------------------------------------------
// CHECK BOTTOM BOUNDARY (transitioning to strate below)
//---------------------------------------------------------------------
// DistFromBottom = how many chunks above the bottom edge of this strate.
// When 0, we're right at the boundary. When == TransitionBlendChunks, we're at
// the outer edge of the transition zone.
int32 DistFromBottom = ChunkCoord.Z - Slot.BottomChunkZ;
if (SlotIdx + 1 < StrateLayout.Num())
{
// The upper strate (this one) controls the transition type at its lower edge
const EVoxelStrateTransition TransType = Slot.Definition->TransitionType;
// Per-definition blend distance.
const int32 EffectiveBlend = Slot.Definition->TransitionBlendChunks;
// Prepare the neighbor's params (only used for Gradient and Interleaved)
const FStrateSlot& BelowSlot = StrateLayout[SlotIdx + 1];
switch (TransType)
{
case EVoxelStrateTransition::Hard:
{
// HARD TRANSITION: No blending. The current strate's params apply
// all the way to the boundary with zero transition zone.
// The abrupt param change (different densities, room sizes, etc.)
// creates a natural cliff or ledge — no special density boost needed.
// We simply skip blending and fall through to the "return BaseParams" below.
break;
}
case EVoxelStrateTransition::Gradient:
{
// GRADIENT TRANSITION: Classic smooth lerp across the blend zone.
// Alpha goes from 0 (at the outer edge of the zone) to 1 (right at boundary).
if (EffectiveBlend > 0 && DistFromBottom < EffectiveBlend)
{
FStrateGenerationParams BelowParams = BuildParamsFromDefinition(BelowSlot.Definition);
BelowParams.StrateTopWorldZ = (float)(BelowSlot.TopChunkZ + 1) * CHUNK_SIZE;
BelowParams.StrateBottomWorldZ = (float)(BelowSlot.BottomChunkZ) * CHUNK_SIZE;
// Linear alpha: 0 at EffectiveBlend chunks away, 1 at the boundary
float Alpha = 1.0f - ((float)DistFromBottom / (float)EffectiveBlend);
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
return ResolveFinalParams(
FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
}
break;
}
case EVoxelStrateTransition::Interleaved:
{
if (EffectiveBlend <= 0) { break; }
// INTERLEAVED TRANSITION: 3D noise warps the effective boundary Z.
//
// Instead of a flat boundary plane, the boundary becomes a wavy 3D surface.
// For each XY position, a Perlin noise sample offsets the boundary Z by
// up to ±2 chunks. Where the noise pushes the boundary UP, the lower strate's
// params appear earlier (its "fingers" reach into the upper strate). Where
// the noise pushes DOWN, the upper strate's params persist longer.
//
// The Z frequency is intentionally 3x lower than XY frequency so the fingers
// are horizontal slabs rather than vertical spikes — this matches how real
// geological intrusions look (wide, flat, layered).
//
// WarpAmplitude of 2.0 means the boundary can shift ±2 chunks from its
// true position. Combined with EffectiveBlend for the transition width,
// we need to check a wider zone: EffectiveBlend + WarpAmplitude.
const float WarpAmplitude = 2.0f; // Max boundary offset in chunks
const int32 CheckRange = EffectiveBlend + FMath::CeilToInt(WarpAmplitude);
if (DistFromBottom < CheckRange)
{
FStrateGenerationParams BelowParams = BuildParamsFromDefinition(BelowSlot.Definition);
BelowParams.StrateTopWorldZ = (float)(BelowSlot.TopChunkZ + 1) * CHUNK_SIZE;
BelowParams.StrateBottomWorldZ = (float)(BelowSlot.BottomChunkZ) * CHUNK_SIZE;
// Sample 3D Perlin noise to warp the boundary position.
// XY frequency 0.15 gives medium-scale variation (~6-7 chunks per cycle).
// Z frequency 0.05 gives slow vertical change — horizontal finger shapes.
// CachedSeed offsets ensure each world has unique finger patterns.
float WarpNoise = FMath::PerlinNoise3D(FVector(
ChunkCoord.X * 0.15f + CachedSeed * 0.01f,
ChunkCoord.Y * 0.15f + CachedSeed * 0.017f,
ChunkCoord.Z * 0.05f // Lower Z frequency for horizontal "fingers"
)) * VOXEL_NOISE_SCALE;
// Offset the distance from boundary by the noise * amplitude.
// Positive noise → boundary pushed up → lower strate appears earlier.
// Negative noise → boundary pushed down → upper strate persists longer.
float WarpedDist = (float)DistFromBottom + WarpNoise * WarpAmplitude;
// Compute alpha from the warped distance (same formula as Gradient,
// but using the noise-displaced distance instead of the true distance)
float Alpha = 1.0f - FMath::Clamp(WarpedDist / (float)EffectiveBlend, 0.0f, 1.0f);
// Only blend if alpha > 0 (we're inside the warped transition zone)
if (Alpha > 0.0f)
{
return ResolveFinalParams(
FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
}
}
break;
}
}
}
//---------------------------------------------------------------------
// CHECK TOP BOUNDARY (transitioning to strate above)
//---------------------------------------------------------------------
// Mirror logic: the ABOVE strate's TransitionType controls its lower edge,
// which is this strate's upper edge. So we read from StrateLayout[SlotIdx-1].
int32 DistFromTop = Slot.TopChunkZ - ChunkCoord.Z;
if (SlotIdx > 0)
{
// The strate ABOVE controls the transition at its lower edge (= our upper edge)
const FStrateSlot& AboveSlot = StrateLayout[SlotIdx - 1];
const EVoxelStrateTransition TransType = AboveSlot.Definition->TransitionType;
const int32 EffectiveBlend = AboveSlot.Definition->TransitionBlendChunks;
switch (TransType)
{
case EVoxelStrateTransition::Hard:
{
// No blending — fall through to return BaseParams
break;
}
case EVoxelStrateTransition::Gradient:
{
if (EffectiveBlend > 0 && DistFromTop < EffectiveBlend)
{
FStrateGenerationParams AboveParams = BuildParamsFromDefinition(AboveSlot.Definition);
AboveParams.StrateTopWorldZ = (float)(AboveSlot.TopChunkZ + 1) * CHUNK_SIZE;
AboveParams.StrateBottomWorldZ = (float)(AboveSlot.BottomChunkZ) * CHUNK_SIZE;
float Alpha = 1.0f - ((float)DistFromTop / (float)EffectiveBlend);
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
return ResolveFinalParams(
FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
}
break;
}
case EVoxelStrateTransition::Interleaved:
{
if (EffectiveBlend <= 0) { break; }
const float WarpAmplitude = 2.0f;
const int32 CheckRange = EffectiveBlend + FMath::CeilToInt(WarpAmplitude);
if (DistFromTop < CheckRange)
{
FStrateGenerationParams AboveParams = BuildParamsFromDefinition(AboveSlot.Definition);
AboveParams.StrateTopWorldZ = (float)(AboveSlot.TopChunkZ + 1) * CHUNK_SIZE;
AboveParams.StrateBottomWorldZ = (float)(AboveSlot.BottomChunkZ) * CHUNK_SIZE;
// Same noise function but with a different seed offset to avoid
// symmetry between top and bottom boundaries of adjacent strates
float WarpNoise = FMath::PerlinNoise3D(FVector(
ChunkCoord.X * 0.15f + CachedSeed * 0.013f,
ChunkCoord.Y * 0.15f + CachedSeed * 0.023f,
ChunkCoord.Z * 0.05f
)) * VOXEL_NOISE_SCALE;
float WarpedDist = (float)DistFromTop + WarpNoise * WarpAmplitude;
float Alpha = 1.0f - FMath::Clamp(WarpedDist / (float)EffectiveBlend, 0.0f, 1.0f);
if (Alpha > 0.0f)
{
return ResolveFinalParams(
FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
}
}
break;
}
}
}
// Not near any boundary (or Hard transition) — use this strate's params directly
return ResolveFinalParams(BaseParams);
}
//=============================================================================
// BUILD PARAMS FROM DEFINITION
//=============================================================================
// Returns the definition's base GenerationParams (cave shape, SDF, roughness, etc.).
//
// NOTE: Terrain op fields (TerraceStepHeight, ColumnDensity, etc.) are not
// merged here. They default to 0 (disabled) in the base params, and are applied
// per-room during BuildChunkCache() via FCachedRoom::RoomOp — each room hash-rolls
// one op from the strate's probability pool (FStrateTerrainOpEntry::Probability).
//
// Assets are still pre-loaded in Initialize() so BuildChunkCache can resolve
// soft pointers (Entry.Operation.Get()) without a disk read during generation.
FStrateGenerationParams UVoxelStrateManager::BuildParamsFromDefinition(const UVoxelStrateDefinition* Definition)
{
if (!Definition) return FStrateGenerationParams();
// Base params only — terrain op fields stay 0 until per-room assignment. Resolve the asset
// switch here as well as at the final return so a disabled neighbour cannot leak worm strength
// back through a boundary blend.
FStrateGenerationParams Result = Definition->GenerationParams;
if (VF_WormsForceOff() || !Definition->bEnableWorms)
{
Result.WormStrength = 0.0f;
}
return Result;
}
Reference in new issue View Git Blame Copy Permalink