Fr0zka/VoxelForge
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: sanitizer sweep across all generators; bound signed shifts/division/overflow at coordinate limits (L61); R31

Browse Source 
New verify.py sanitize tier (Clang address,undefined,float-cast-overflow; GCC address,undefined;
-fno-sanitize-recover) runs 19 cases per compiler at LOD0-8 across every generator, passages and the
crossing: 0 runtime reports; a planted signed-overflow control is caught by both. A static scan fixed
INT_MIN negation in floor division, unbounded signed LOD shifts and coordinate-times-extent overflow in
VoxelClipmapDesiredTiles.h and VoxelTypes.h (plugin and standalone), and VoxelWorld.cpp, VoxelContentManager.cpp
and VoxelDensityVolume.cpp (plugin only, uncompiled here). Supported-input output unchanged (version 211).
fast/medium/full PASS. Research R31 (self-checked): far-LOD 4-8 cut plan.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
This commit is contained in:
Fr0zkaandClaude Opus 5.5 committed 2026-10-26 05:19:18 +01:00
1 parent c0c204ba50
commit 135957831b
13 files changed
+760 -132
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Source/VoxelForge/Private/VoxelWorld.cpp
+60 -27
View File
@@ -82,6 +82,17 @@
#include <atomic>
#include <unordered_set>
static FORCEINLINE int32 VF_ClipLevelScale(int32 Level)
{
const uint32 SafeLevel = static_cast<uint32>(FMath::Clamp(Level, 0, 8));
return static_cast<int32>(uint32{1} << SafeLevel);
}
static FORCEINLINE int32 VF_ClipLevelExtentVoxels(int32 Level)
{
return static_cast<int32>(static_cast<uint32>(CHUNK_SIZE)
* static_cast<uint32>(VF_ClipLevelScale(Level)));
}
static bool VF_TileOverlapsVoxelBounds(const FVoxelTileKey& Tile,
const FVector& BoundsMin, const FVector& BoundsMax);
static bool VF_TileFootprintsOverlap(const FVoxelTileKey& A, const FVoxelTileKey& B);
@@ -6240,17 +6251,19 @@ static void VF_AppendTouchingAncestors(
const FVoxelTileKey& Tile, int32 AncestorLevel, CandidateArray& OutCandidates)
{
if (AncestorLevel <= Tile.Level) { return; }
const int32 Divisor = 1 << (AncestorLevel - Tile.Level);
const auto FloorDiv = [Divisor](int32 Value)
const int32 Divisor = VF_ClipLevelScale(AncestorLevel - Tile.Level);
const auto FloorDiv = [Divisor](int64 Value)
{
return Value >= 0 ? Value / Divisor : -(((-Value) + Divisor - 1) / Divisor);
const int64 Quotient = Value / Divisor;
const int64 Remainder = Value % Divisor;
return static_cast<int32>(Remainder < 0 ? Quotient - 1 : Quotient);
};
const auto AxisCandidates = [&FloorDiv, Divisor](int32 Value)
{
TArray<int32, TInlineAllocator<2>> Candidates;
int32 First = FloorDiv(Value);
if ((Value % Divisor) == 0) { --First; }
const int32 Last = FloorDiv(Value + 1);
const int32 Last = FloorDiv(static_cast<int64>(Value) + 1);
for (int32 Coord = First; Coord <= Last; ++Coord) { Candidates.Add(Coord); }
return Candidates;
};
@@ -6338,7 +6351,7 @@ void AVoxelWorld::UpdateVisualStalenessAudit()
const FVector& WorldPosition, int32 Level, auto& OutCandidates)
{
const FVector LocalVoxel = WorldToLocalVoxel(WorldPosition);
const float TileExtentVoxels = static_cast<float>(CHUNK_SIZE * (1 << Level));
const float TileExtentVoxels = static_cast<float>(VF_ClipLevelExtentVoxels(Level));
TArray<int32, TInlineAllocator<2>> XCandidates;
TArray<int32, TInlineAllocator<2>> YCandidates;
TArray<int32, TInlineAllocator<2>> ZCandidates;
@@ -7182,7 +7195,7 @@ void AVoxelWorld::Tick(float DeltaTime)
{
const FIntVector Min = SteadyLevelMins.FindChecked(Level);
const FIntVector Max = SteadyLevelMaxs.FindChecked(Level);
const int32 ExtentVoxels = CHUNK_SIZE << Level;
const int32 ExtentVoxels = VF_ClipLevelExtentVoxels(Level);
const double TileExtentMetres = static_cast<double>(ExtentVoxels) * VOXEL_SIZE / 100.0;
const double SpanX = static_cast<double>(Max.X - Min.X + 1) * TileExtentMetres;
const double SpanY = static_cast<double>(Max.Y - Min.Y + 1) * TileExtentMetres;
@@ -7663,10 +7676,20 @@ bool AVoxelWorld::InitializeVoxelForgeCoreWorld(FString& OutFailureReason)
};
for (const VoxelForgeCore::TileKey& Key : InitialDesired)
{
const int32 Extent = 32 << Key.lod;
const int32 OriginX = Key.coordinate.x * Extent;
const int32 OriginY = Key.coordinate.y * Extent;
const int32 OriginZ = Key.coordinate.z * Extent;
const int32 Extent = VF_ClipLevelExtentVoxels(Key.lod);
const int64 OriginXWide = static_cast<int64>(Key.coordinate.x) * Extent;
const int64 OriginYWide = static_cast<int64>(Key.coordinate.y) * Extent;
const int64 OriginZWide = static_cast<int64>(Key.coordinate.z) * Extent;
if (OriginXWide < MIN_int32 || OriginYWide < MIN_int32 || OriginZWide < MIN_int32
|| OriginXWide + Extent > MAX_int32 || OriginYWide + Extent > MAX_int32
|| OriginZWide + Extent > MAX_int32)
{
OutFailureReason = TEXT("Core initial clipmap exceeds the supported voxel-coordinate range.");
return false;
}
const int32 OriginX = static_cast<int32>(OriginXWide);
const int32 OriginY = static_cast<int32>(OriginYWide);
const int32 OriginZ = static_cast<int32>(OriginZWide);
IncludeExtent(ClipMin.x, ClipMax.x, OriginX, Extent);
IncludeExtent(ClipMin.y, ClipMax.y, OriginY, Extent);
IncludeExtent(ClipMin.z, ClipMax.z, OriginZ, Extent);
@@ -10074,8 +10097,11 @@ void AVoxelWorld::SyncRemeshTile(const FVoxelTileKey& Tile)
{
BandChunkLo = MeshBandChunkLo;
BandChunkHi = MeshBandChunkHi;
BandVoxLo = MeshBandChunkLo * CHUNK_SIZE;
BandVoxHi = (MeshBandChunkHi + 1) * CHUNK_SIZE - 1;
BandVoxLo = static_cast<int32>(FMath::Clamp<int64>(
static_cast<int64>(MeshBandChunkLo) * CHUNK_SIZE, MIN_int32, MAX_int32));
BandVoxHi = static_cast<int32>(FMath::Clamp<int64>(
(static_cast<int64>(MeshBandChunkHi) + 1) * CHUNK_SIZE - 1,
MIN_int32, MAX_int32));
}
FChunkResult Result;
@@ -10238,7 +10264,7 @@ void AVoxelWorld::ReconcileReadyTransitionVisibility()
ReadyToHide.Reserve(TileComponents.Num());
auto GetAncestorAtLevel = [](const FVoxelTileKey& Tile, int32 AncestorLevel)
{
const int32 Divisor = 1 << (AncestorLevel - Tile.Level);
const int32 Divisor = VF_ClipLevelScale(AncestorLevel - Tile.Level);
return FVoxelTileKey(VoxelClipmapDesiredTiles::FloorDiv(Tile.Coord, Divisor), AncestorLevel);
};
for (const TPair<FVoxelTileKey, URealtimeMeshComponent*>& Pair : TileComponents)
@@ -10361,7 +10387,10 @@ void AVoxelWorld::ReconcileReadyTransitionVisibility()
// Integer floor-division (correct for negatives), scalar + vector.
static FORCEINLINE int32 VF_FloorDiv(int32 V, int32 D)
{
return V >= 0 ? (V / D) : -(((-V) + D - 1) / D);
if (D <= 0) { return 0; }
const int32 Quotient = V / D;
const int32 Remainder = V % D;
return Remainder < 0 ? Quotient - 1 : Quotient;
}
static FORCEINLINE FIntVector VF_FloorDiv(const FIntVector& V, int32 D)
{
@@ -11441,13 +11470,13 @@ bool AVoxelWorld::IsTileInClipRange(const FVoxelTileKey& Tile, const FIntVector&
{
VF_OuterShell(Settings, R, MaxLevelBase, MaxLevel, ROuter);
}
const int32 PowMax = 1 << MaxLevel;
const int32 PowMax = VF_ClipLevelScale(MaxLevel);
const FIntVector CMax = VF_FloorDiv(Center, PowMax);
FVector CV;
if (bUseVoxelForgeCore)
{
const double TileExtentVoxels = static_cast<double>(CHUNK_SIZE << Tile.Level);
const double TileExtentVoxels = static_cast<double>(VF_ClipLevelExtentVoxels(Tile.Level));
CV = FVector(
(static_cast<double>(Tile.Coord.X) + 0.5) * TileExtentVoxels,
(static_cast<double>(Tile.Coord.Y) + 0.5) * TileExtentVoxels,
@@ -11463,9 +11492,9 @@ bool AVoxelWorld::IsTileInClipRange(const FVoxelTileKey& Tile, const FIntVector&
VF_FloorDiv(FMath::FloorToInt(CV.Y), SizeMax),
VF_FloorDiv(FMath::FloorToInt(CV.Z), SizeMax));
return FMath::Abs(TMax.X - CMax.X) <= ROuter
&& FMath::Abs(TMax.Y - CMax.Y) <= ROuter
&& FMath::Abs(TMax.Z - CMax.Z) <= ROuter;
return FMath::Abs(static_cast<int64>(TMax.X) - CMax.X) <= ROuter
&& FMath::Abs(static_cast<int64>(TMax.Y) - CMax.Y) <= ROuter
&& FMath::Abs(static_cast<int64>(TMax.Z) - CMax.Z) <= ROuter;
}
int32 AVoxelWorld::GetMaxConcurrentTasks() const
@@ -12058,7 +12087,7 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
LevelSummaries.Num(), Leavers.Num(), CollisionOnlyTiles.Num()));
for (const FDesiredLevelSummary& Summary : LevelSummaries)
{
const int32 ExtentVoxels = CHUNK_SIZE << Summary.Level;
const int32 ExtentVoxels = VF_ClipLevelExtentVoxels(Summary.Level);
const double TileExtentMetres = static_cast<double>(ExtentVoxels) * VOXEL_SIZE / 100.0;
const double SpanX = static_cast<double>(Summary.Max.X - Summary.Min.X + 1) * TileExtentMetres;
const double SpanY = static_cast<double>(Summary.Max.Y - Summary.Min.Y + 1) * TileExtentMetres;
@@ -12109,8 +12138,9 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
for (const FVoxelTileKey& T : LoadedTiles)
{
if (T.Level < CutMin) continue;
const int32 CLo = T.Coord.Z << T.Level;
const int32 CHi = ((T.Coord.Z + 1) << T.Level) - 1;
const int64 LevelScale = VF_ClipLevelScale(T.Level);
const int64 CLo = static_cast<int64>(T.Coord.Z) * LevelScale;
const int64 CHi = (static_cast<int64>(T.Coord.Z) + 1) * LevelScale - 1;
const bool bInOld = CLo >= MeshBandChunkLo && CHi <= MeshBandChunkHi;
const bool bInNew = CLo >= NewLo && CHi <= NewHi;
const bool bOutOld = CHi < MeshBandChunkLo || CLo > MeshBandChunkHi;
@@ -12330,7 +12360,7 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
}
Heading = Heading.GetSafeNormal();
const FVector PlayerLocalCm = WorldToLocalCm(CenterPosition);
const double TileSizeCm = static_cast<double>(CHUNK_SIZE << Level)
const double TileSizeCm = static_cast<double>(VF_ClipLevelExtentVoxels(Level))
* GetActiveVoxelSizeCm();
LevelTiles.Sort([&](const FVoxelTileKey& A, const FVoxelTileKey& B)
{
@@ -12788,7 +12818,7 @@ void AVoxelWorld::LoadTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority Wor
const int32 FullRes = GVoxelForgeTestFullResClipLevels >= 0
? FMath::Clamp(GVoxelForgeTestFullResClipLevels, 1, 9)
: (Settings ? FMath::Max(1, Settings->FullResClipLevels) : 2);
const int32 Extent = CHUNK_SIZE << Tile.Level;
const int32 Extent = VF_ClipLevelExtentVoxels(Tile.Level);
const int32 Cells = (Tile.Level < FullRes)
? CHUNK_SIZE
@@ -12853,7 +12883,9 @@ void AVoxelWorld::LoadTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority Wor
// et mélanges de matériaux qu'avant la coupe) — la tuile ne peut rendre que des artefacts
// ⇒ on n'émet RIEN. Résultat vide via ProcessQueue (bookkeeping normal : PendingTiles,
// LoadedTiles, epoch) ; jamais figé — le changement de bande re-queue via BandRemeshQueue.
if (Step > (BandChunkHi - BandChunkLo + 1) * CHUNK_SIZE)
const int64 BandHeightVoxels =
(static_cast<int64>(BandChunkHi) - BandChunkLo + 1) * CHUNK_SIZE;
if (static_cast<int64>(Step) > BandHeightVoxels)
{
FChunkResult Empty;
Empty.Tile = Tile;
@@ -13988,7 +14020,8 @@ bool AVoxelWorld::ApplyMeshToTile(FChunkResult& Result)
// Convertir les bornes physiques de tuile vers les strates owner, y compris les rapports fractionnaires.
const double OwnerChunksPerCoreTile = static_cast<double>(GetActiveVoxelSizeCm())
/ VOXEL_SIZE;
const double TileExtentCoreVoxels = static_cast<double>(CHUNK_SIZE << Tile.Level);
const double TileExtentCoreVoxels =
static_cast<double>(VF_ClipLevelExtentVoxels(Tile.Level));
const int32 MinOwnerChunkX = FMath::FloorToInt(
Tile.Coord.X * TileExtentCoreVoxels * OwnerChunksPerCoreTile / CHUNK_SIZE);
const int32 MinOwnerChunkY = FMath::FloorToInt(
@@ -15180,7 +15213,7 @@ void AVoxelWorld::RemeshDirtyChunks(const TArray<FIntVector>& DirtyCoords, const
// BackgroundHigh; the old component remains visible until its post-edit replacement is applied.
auto TileCoversDirtyCoord = [&DirtyCoords](const FVoxelTileKey& Tile) -> bool
{
const int32 Span = 1 << Tile.Level;
const int32 Span = VF_ClipLevelScale(Tile.Level);
const FIntVector MinChunk = Tile.Coord * Span;
const FIntVector MaxChunk = MinChunk + FIntVector(Span, Span, Span);
for (const FIntVector& Coord : DirtyCoords)