Fr0zka/VoxelForge
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b0a14262b172d1bb9aec0fa036fe6b54210d3a35
VoxelForge/Standalone/Source/StandaloneViewer.cpp
T
Fr0zkaandClaude Opus 5.5 b0a14262b1 wip(standalone): GPU step 6 -- near field on GPU, exact; cold start still slower than CPU 
Near LOD0/1 (detail band, relief, root refinement, normals) now evaluated and
meshed on the GPU. 960 near tiles: zero sign/topology differences vs CPU and
WARP, vertex max 0.0049 mm (was 15 cm); far survival audit passes; CPU hashes
44/44 unchanged. Far connector-panel outlier (64.56 cm, LOD8) remains a
tessellation difference, and remote captures show missing far geometry on GPU.

Cold readiness (viewer clock, my interleaved runs): CPU 2.51/2.49/2.40 s,
GPU 5.05/2.68/2.80 s. The ~2.1 s Present stall hit only the first GPU launch.
Viewer spends ~1.13 s before shape compile starts (startup checks), which is
the gap between the 0.95 s benchmark and ~2.4 s on-screen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MmSoF64BbRFmk9C3p1VsBJ
2026-10-06 20:03:10 +02:00

5410 lines
315 KiB
C++
Raw Blame History

#include "OwnerWorldLoader.h"
#include "StreamingWorld.h"
#include "StandaloneCoreScheduler.h"
#include "../Core/src/StandaloneSnapshotAdapter.h"
#include "../Research/OwnerShapeWorld/gpu_field_port/GpuFarViewer.h"
#include "VoxelDensityProfile.h"
#ifdef TEXT
#undef TEXT
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <d3d11.h>
#include <d3dcompiler.h>
#include <dxgi.h>
#include <windowsx.h>
#include <atomic>
#include <bit>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <optional>
#include <sstream>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#pragma comment(lib,"d3d11.lib")
#pragma comment(lib,"dxgi.lib")
#pragma comment(lib,"d3dcompiler.lib")
#pragma comment(lib,"user32.lib")
#pragma comment(lib,"gdi32.lib")
namespace
{
struct V3 { float X=0.0f,Y=0.0f,Z=0.0f; };
V3 Add(V3 A,V3 B){return {A.X+B.X,A.Y+B.Y,A.Z+B.Z};}
V3 Sub(V3 A,V3 B){return {A.X-B.X,A.Y-B.Y,A.Z-B.Z};}
V3 Mul(V3 A,float S){return {A.X*S,A.Y*S,A.Z*S};}
float Dot(V3 A,V3 B){return A.X*B.X+A.Y*B.Y+A.Z*B.Z;}
V3 Cross(V3 A,V3 B){return {A.Y*B.Z-A.Z*B.Y,A.Z*B.X-A.X*B.Z,A.X*B.Y-A.Y*B.X};}
V3 Normalize(V3 A){return Mul(A,1.0f/std::sqrt(std::max(1.0e-20f,Dot(A,A))));}
#include "FarSurvivalAudit.h"
struct FMeshSheetAudit
{
uint64 Components=0;
uint64 SmallComponents=0;
uint64 SmallComponentsInView=0;
uint64 BoundarySmallComponentsInView=0;
uint64 ThinSheets=0;
uint64 TrianglesInThinSheets=0;
double MinimumThicknessVoxels=std::numeric_limits<double>::max();
};
struct FMeshArtifactAudit
{
uint64 Tiles=0,SurfaceVertices=0,EdgeVertices=0,MidpointVertices=0;
uint64 SkirtTriangles=0,HiddenSameLodSkirtTriangles=0,ExposedSkirtTriangles=0,
ReverseSideSolidSkirtTriangles=0,RepeatedOffsetPatches=0,FieldMismatchPatches=0,
NormalMismatchPatches=0,GradientFallbackPatches=0,GradientFallbackSamples=0,
DetailDisplacementSamples=0,HighDetailDisplacementSamples=0,DetailDisplacementPatches=0,
CurvedEdgeChecks=0,CurvedEdgeRootPatches=0,CurvedEdgeRootBadVertices=0,
DetailGradientSamples=0,DetailGradientOverLimit=0;
double MaximumAirSkirtDensity=0.0,MaximumPatchDominance=0.0;
double MaximumDetailDisplacement=0.0;
double MaximumCurvedEdgeRootError=0.0;
double MaximumDetailGradient=0.0;
uint64 FieldEdgeChecks=0,AnalyticCrossingMisses=0,OldInt8RangeEdges=0,NormalChecks=0;
double SumAbsSourceResidual=0.0,MaximumAbsSourceResidual=0.0,
SumAnalyticEdgeShiftVoxels=0.0,MaximumAnalyticEdgeShiftVoxels=0.0,
SumNormalAgreement=0.0,MinimumNormalAgreement=1.0;
std::array<double,3> WorstShiftPosition{},WorstResidualPosition{};
double WorstShiftFraction=0.0,WorstShiftD0=0.0,WorstShiftD1=0.0,
WorstShiftExactD0=0.0,WorstShiftExactD1=0.0;
int32 WorstShiftAxis=-1;
std::array<uint64,16> OffsetHistogram{};
};
uint8 ComputeVisibleSkirtFaceMask(const FVoxelTileKey& Tile,
const std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash>& Desired)
{
const FIntVector Origin=Tile.OriginVoxels();
const int32 Extent=Tile.ExtentVoxels();
const auto FloorDiv=[](int64 Value,int64 Divisor)
{
int64 Quotient=Value/Divisor;
if(Value%Divisor<0)--Quotient;
return static_cast<int32>(Quotient);
};
uint8 Mask=0;
for(int32 Axis=0;Axis<3;++Axis)
for(int32 Side=0;Side<2;++Side)
{
int64 Probe[3]={Origin.X+Extent/2,Origin.Y+Extent/2,Origin.Z+Extent/2};
Probe[Axis]=Side?static_cast<int64>((&Origin.X)[Axis])+Extent
:static_cast<int64>((&Origin.X)[Axis])-1;
int32 NeighborLevel=-1;
for(int32 Level=0;Level<=8;++Level)
{
const int64 NeighborExtent=static_cast<int64>(CHUNK_SIZE)<<Level;
const FIntVector Coord(FloorDiv(Probe[0],NeighborExtent),
FloorDiv(Probe[1],NeighborExtent),FloorDiv(Probe[2],NeighborExtent));
if(Desired.contains(FVoxelTileKey(Coord,Level)))
{NeighborLevel=Level;break;}
}
if(NeighborLevel<0||NeighborLevel!=Tile.Level)
Mask|=static_cast<uint8>(1u<<(Axis*2+Side));
}
return Mask;
}
FMeshArtifactAudit AuditMeshArtifacts(const FStandaloneCpuTile& Tile,
const VoxelForgeCore::World& Shape,double SkirtDepthMeters,uint8 VisibleSkirtFaceMask,
bool bPrintSkirts,bool bPrintPatches)
{
FMeshArtifactAudit Result;
if(Tile.Key.Level<0||Tile.Key.Level>1||Tile.Vertices.empty()||Tile.Indices.size()<3)
return Result;
++Result.Tiles;
const size_t VertexCount=Tile.Vertices.size();
const size_t SurfaceVertices=std::min<size_t>(Tile.SurfaceVertexCount,VertexCount);
Result.SurfaceVertices=SurfaceVertices;
const int32 Step=1<<Tile.Key.Level;
const FIntVector Origin=Tile.Key.OriginVoxels();
using FBlockKey=std::array<int32,4>; // interpolated axis, then the 8-voxel block xyz
struct FFieldBlock
{uint64 Vertices=0,BadVertices=0;double MaximumShift=0.0,MaximumResidual=0.0;
std::array<double,3> Position{};};
struct FNormalBlock
{uint64 Vertices=0,BadVertices=0;double MinimumAgreement=1.0;
std::array<double,3> Position{},MeshNormal{};};
struct FGradientFallbackBlock
{uint64 Vertices=0,BadVertices=0,BadSamples=0;double MaximumError=0.0;
std::array<double,3> Position{};};
struct FCurvedEdgeRootBlock
{uint64 Vertices=0,BadVertices=0;double MaximumError=0.0;
std::array<double,3> Position{};};
std::map<FBlockKey,std::array<uint64,256>> OffsetBlocks;
std::map<FBlockKey,FFieldBlock> FieldBlocks;
std::map<FBlockKey,FNormalBlock> NormalBlocks;
std::map<FBlockKey,FGradientFallbackBlock> GradientFallbackBlocks;
std::map<FBlockKey,FCurvedEdgeRootBlock> CurvedEdgeRootBlocks;
struct FDetailDisplacementBlock
{uint64 Vertices=0,HighVertices=0;double Maximum=0.0,MaximumGradient=0.0;std::array<double,3> Position{};};
std::map<std::array<int32,3>,FDetailDisplacementBlock> DetailDisplacementBlocks;
std::map<FBlockKey,std::array<double,3>> FirstPositionByBlock;
std::map<FBlockKey,std::array<double,3>> FirstNormalByBlock;
uint64 RayTileResidualSamples=0,RayTileResidualGt01=0,
RayTileResidualGt025=0,RayTileResidualGt05=0;
double RayTileResidualSum=0.0,RayTileResidualMaximum=0.0;
std::array<double,3> RayTileResidualMaximumPosition{};
uint64 RayTileInteriorSamples=0,RayTileInteriorGt0125=0,
RayTileInteriorGt025=0,RayTileInteriorGt05=0,RayTileInteriorGt1=0;
double RayTileInteriorResidualSum=0.0,RayTileInteriorResidualMaximum=0.0;
std::array<double,3> RayTileInteriorMaximumPosition{};
for(size_t I=0;I<SurfaceVertices;++I)
{
const auto& Position=Tile.Vertices[I].Position;
const double P[3]={Position[0]*4.0,Position[1]*4.0,Position[2]*4.0};
double DetailGradientAtVertex=0.0;
if(Tile.Key.Level==0)
{
const VoxelForgeCore::DetailFieldSample DetailSample=Shape.detailSampleAt(
{P[0],P[1],P[2]});
if(DetailSample.caveInfluence>=0.60f&&DetailSample.floorInfluence>=0.60f)
{
constexpr double GradientProbeOffset=0.5;
double DetailGradientSquared=0.0;
for(int32 Axis=0;Axis<3;++Axis)
{
double Minus[3]={P[0],P[1],P[2]};
double Plus[3]={P[0],P[1],P[2]};
Minus[Axis]-=GradientProbeOffset;
Plus[Axis]+=GradientProbeOffset;
const double DMinus=Shape.detailSampleAt(
{Minus[0],Minus[1],Minus[2]}).displacement;
const double DPlus=Shape.detailSampleAt(
{Plus[0],Plus[1],Plus[2]}).displacement;
const double Gradient=(DPlus-DMinus)/(2.0*GradientProbeOffset);
DetailGradientSquared+=Gradient*Gradient;
}
const double DetailGradient=std::sqrt(DetailGradientSquared);
DetailGradientAtVertex=DetailGradient;
++Result.DetailGradientSamples;
Result.MaximumDetailGradient=std::max(
Result.MaximumDetailGradient,DetailGradient);
if(DetailGradient>0.55)++Result.DetailGradientOverLimit;
const double DetailDisplacement=std::abs(DetailSample.displacement);
++Result.DetailDisplacementSamples;
Result.MaximumDetailDisplacement=std::max(
Result.MaximumDetailDisplacement,DetailDisplacement);
const std::array<int32,3> DetailKey{
static_cast<int32>(std::floor((P[0]-Origin.X)/8.0)),
static_cast<int32>(std::floor((P[1]-Origin.Y)/8.0)),
static_cast<int32>(std::floor((P[2]-Origin.Z)/8.0))};
FDetailDisplacementBlock& DetailBlock=DetailDisplacementBlocks[DetailKey];
++DetailBlock.Vertices;
DetailBlock.MaximumGradient=std::max(DetailBlock.MaximumGradient,DetailGradientAtVertex);
if(DetailDisplacement>0.65)
{
++DetailBlock.HighVertices;
if(DetailDisplacement>DetailBlock.Maximum)
{
DetailBlock.Maximum=DetailDisplacement;
DetailBlock.Position={P[0],P[1],P[2]};
}
++Result.HighDetailDisplacementSamples;
}
}
}
double Grid[3];int32 VariableAxis=-1;
for(int32 Axis=0;Axis<3;++Axis)
{
Grid[Axis]=(P[Axis]-(&Origin.X)[Axis])/Step;
if(std::abs(Grid[Axis]-std::round(Grid[Axis]))>0.003)
{
if(VariableAxis>=0){VariableAxis=-2;break;}
VariableAxis=Axis;
}
}
if(VariableAxis<0)continue;
double Fraction=Grid[VariableAxis]-std::floor(Grid[VariableAxis]);
if(Fraction<0.003||Fraction>0.997)continue;
++Result.EdgeVertices;
const int32 CoarseBin=std::clamp(static_cast<int32>(Fraction*16.0),0,15);
const int32 PreciseBin=std::clamp(static_cast<int32>(std::lround(Fraction*256.0)),0,255);
++Result.OffsetHistogram[CoarseBin];
if(CoarseBin==7||CoarseBin==8)++Result.MidpointVertices;
double EdgeA[3],EdgeB[3];
for(int32 Axis=0;Axis<3;++Axis)
{
const int32 Cell=static_cast<int32>(std::floor(Grid[Axis]));
EdgeA[Axis]=(&Origin.X)[Axis]+Cell*Step;
EdgeB[Axis]=EdgeA[Axis];
}
EdgeB[VariableAxis]+=Step;
const double D0=Shape.densityAt({EdgeA[0],EdgeA[1],EdgeA[2]});
const double D1=Shape.densityAt({EdgeB[0],EdgeB[1],EdgeB[2]});
const double ExactD0=Shape.unclampedDensityAt(
{EdgeA[0]+0.013,EdgeA[1]+0.013,EdgeA[2]+0.013});
const double ExactD1=Shape.unclampedDensityAt(
{EdgeB[0]+0.013,EdgeB[1]+0.013,EdgeB[2]+0.013});
const double ExactDenominator=ExactD1-ExactD0;
++Result.FieldEdgeChecks;
if(std::abs(D0)>127.0/256.0||std::abs(D1)>127.0/256.0)
++Result.OldInt8RangeEdges;
const bool bExactCrossing=(ExactD0<0.0&&ExactD1>0.0)
||(ExactD0>0.0&&ExactD1<0.0);
double AnalyticShift=0.0;
if(bExactCrossing&&std::abs(ExactDenominator)>1.0e-9)
{
const double ExactT=std::clamp(-ExactD0/ExactDenominator,0.0,1.0);
AnalyticShift=std::abs(Fraction-ExactT)*Step;
Result.SumAnalyticEdgeShiftVoxels+=AnalyticShift;
if(AnalyticShift>Result.MaximumAnalyticEdgeShiftVoxels)
{
Result.MaximumAnalyticEdgeShiftVoxels=AnalyticShift;
Result.WorstShiftPosition={P[0],P[1],P[2]};
Result.WorstShiftFraction=Fraction;Result.WorstShiftD0=D0;
Result.WorstShiftD1=D1;Result.WorstShiftExactD0=ExactD0;
Result.WorstShiftExactD1=ExactD1;Result.WorstShiftAxis=VariableAxis;
}
}
else ++Result.AnalyticCrossingMisses;
if(Tile.Key.Level==0&&Step==1&&bExactCrossing
&&Fraction>=0.375&&Fraction<=0.625)
{
const double MidExact=Shape.unclampedDensityAt({
(EdgeA[0]+EdgeB[0])*0.5+0.013,
(EdgeA[1]+EdgeB[1])*0.5+0.013,
(EdgeA[2]+EdgeB[2])*0.5+0.013});
double CurveRootT=0.5;
if(std::abs(MidExact)>1.0e-8)
{
if((MidExact<0.0)==(ExactD0<0.0))
{
const double Denominator=ExactD1-MidExact;
if(std::abs(Denominator)>1.0e-9)
CurveRootT=0.5+0.5*std::clamp(-MidExact/Denominator,0.0,1.0);
}
else
{
const double Denominator=MidExact-ExactD0;
if(std::abs(Denominator)>1.0e-9)
CurveRootT=0.5*std::clamp(-ExactD0/Denominator,0.0,1.0);
}
}
const double CurveError=std::abs(Fraction-CurveRootT);
++Result.CurvedEdgeChecks;
Result.MaximumCurvedEdgeRootError=std::max(
Result.MaximumCurvedEdgeRootError,CurveError);
FBlockKey RootKey{};RootKey[0]=VariableAxis;
for(int32 Axis=0;Axis<3;++Axis)
RootKey[Axis+1]=static_cast<int32>(std::floor(
(P[Axis]-(&Origin.X)[Axis])/8.0));
FCurvedEdgeRootBlock& RootBlock=CurvedEdgeRootBlocks[RootKey];
++RootBlock.Vertices;
if(CurveError>0.08)
{
++RootBlock.BadVertices;
if(CurveError>RootBlock.MaximumError)
{
RootBlock.MaximumError=CurveError;
RootBlock.Position={P[0],P[1],P[2]};
}
++Result.CurvedEdgeRootBadVertices;
}
}
const double SourceResidual=std::abs(Shape.unclampedDensityAt({P[0],P[1],P[2]}));
if(Tile.Key.Level==0&&Tile.Key.Coord.X==1
&&Tile.Key.Coord.Y==-16&&Tile.Key.Coord.Z==-3)
{
++RayTileResidualSamples;
RayTileResidualSum+=SourceResidual;
if(SourceResidual>0.1)++RayTileResidualGt01;
if(SourceResidual>0.25)++RayTileResidualGt025;
if(SourceResidual>0.5)++RayTileResidualGt05;
if(SourceResidual>RayTileResidualMaximum)
{
RayTileResidualMaximum=SourceResidual;
RayTileResidualMaximumPosition={P[0],P[1],P[2]};
}
}
Result.SumAbsSourceResidual+=SourceResidual;
if(SourceResidual>Result.MaximumAbsSourceResidual)
{
Result.MaximumAbsSourceResidual=SourceResidual;
Result.WorstResidualPosition={P[0],P[1],P[2]};
}
const double H=0.5;
const double GX=Shape.unclampedDensityAt({P[0]+H+0.013,P[1]+0.013,P[2]+0.013})
-Shape.unclampedDensityAt({P[0]-H+0.013,P[1]+0.013,P[2]+0.013});
const double GY=Shape.unclampedDensityAt({P[0]+0.013,P[1]+H+0.013,P[2]+0.013})
-Shape.unclampedDensityAt({P[0]+0.013,P[1]-H+0.013,P[2]+0.013});
const double GZ=Shape.unclampedDensityAt({P[0]+0.013,P[1]+0.013,P[2]+H+0.013})
-Shape.unclampedDensityAt({P[0]+0.013,P[1]+0.013,P[2]-H+0.013});
const double GL=std::sqrt(GX*GX+GY*GY+GZ*GZ);
double NormalAgreement=1.0;
if(Tile.Key.Level==0&&GL>1.0e-8)
{
const auto& N=Tile.Vertices[I].Normal;
NormalAgreement=std::clamp((N[0]*GX+N[1]*GY+N[2]*GZ)/GL,-1.0,1.0);
++Result.NormalChecks;Result.SumNormalAgreement+=NormalAgreement;
Result.MinimumNormalAgreement=std::min(Result.MinimumNormalAgreement,NormalAgreement);
}
FBlockKey Key{};Key[0]=VariableAxis;
for(int32 Axis=0;Axis<3;++Axis)
Key[Axis+1]=static_cast<int32>(std::floor((P[Axis]-(&Origin.X)[Axis])/8.0));
if(Tile.Key.Level==0&&GL>1.0e-8)
{
FNormalBlock& NormalBlock=NormalBlocks[Key];
++NormalBlock.Vertices;
if(NormalAgreement<NormalBlock.MinimumAgreement)
{
NormalBlock.MinimumAgreement=NormalAgreement;
NormalBlock.Position={P[0],P[1],P[2]};
NormalBlock.MeshNormal={Tile.Vertices[I].Normal[0],
Tile.Vertices[I].Normal[1],Tile.Vertices[I].Normal[2]};
}
if(NormalAgreement<0.90)++NormalBlock.BadVertices;
}
if(Tile.Key.Level==0)
{
FFieldBlock& FieldBlock=FieldBlocks[Key];
++FieldBlock.Vertices;
FieldBlock.MaximumShift=std::max(FieldBlock.MaximumShift,AnalyticShift);
FieldBlock.MaximumResidual=std::max(FieldBlock.MaximumResidual,SourceResidual);
const bool bBadFieldEdge=SourceResidual>0.5;
if(bBadFieldEdge)
{
++FieldBlock.BadVertices;
if(FieldBlock.BadVertices==1)FieldBlock.Position={P[0],P[1],P[2]};
}
FGradientFallbackBlock& FallbackBlock=GradientFallbackBlocks[Key];
++FallbackBlock.Vertices;
uint64 VertexFallbackSamples=0;
for(int32 Endpoint=0;Endpoint<2;++Endpoint)
{
const double* EdgePoint=Endpoint?EdgeB:EdgeA;
for(int32 Axis=0;Axis<3;++Axis)
for(int32 Side=-1;Side<=1;Side+=2)
{
double Probe[3]={EdgePoint[0],EdgePoint[1],EdgePoint[2]};
Probe[Axis]+=Side;
const double Packed=Shape.densityAt({Probe[0],Probe[1],Probe[2]});
if(std::abs(std::abs(Packed)-4.125)>0.001)continue;
double ExactProbe[3]={Probe[0]+0.013,Probe[1]+0.013,Probe[2]+0.013};
const double Exact=Shape.unclampedDensityAt(
{ExactProbe[0],ExactProbe[1],ExactProbe[2]});
const double Error=std::abs(Packed-Exact);
if(Error<=0.25)continue;
++VertexFallbackSamples;
FallbackBlock.MaximumError=std::max(FallbackBlock.MaximumError,Error);
}
}
if(VertexFallbackSamples>0&&NormalAgreement<0.98)
{
++FallbackBlock.BadVertices;
FallbackBlock.BadSamples+=VertexFallbackSamples;
if(FallbackBlock.BadVertices==1)FallbackBlock.Position={P[0],P[1],P[2]};
}
}
FirstPositionByBlock.try_emplace(Key,std::array<double,3>{P[0],P[1],P[2]});
const auto& Normal=Tile.Vertices[I].Normal;
FirstNormalByBlock.try_emplace(Key,std::array<double,3>{Normal[0],Normal[1],Normal[2]});
++OffsetBlocks[Key][PreciseBin];
}
struct FHighDetailBlock
{std::array<int32,3> Key{};uint64 Vertices=0;double Maximum=0.0,MaximumGradient=0.0;
std::array<double,3> Position{};};
std::vector<FHighDetailBlock> HighDetailBlocks;
for(const auto& [Key,Block]:DetailDisplacementBlocks)
{
if(Block.Vertices<12||Block.HighVertices<6
||static_cast<double>(Block.HighVertices)/Block.Vertices<0.25)continue;
HighDetailBlocks.push_back({Key,Block.HighVertices,Block.Maximum,Block.MaximumGradient,Block.Position});
}
std::vector<uint8> HighDetailVisited(HighDetailBlocks.size(),0);
for(size_t I=0;I<HighDetailBlocks.size();++I)
{
if(HighDetailVisited[I])continue;
std::vector<size_t> Pending{I};HighDetailVisited[I]=1;
uint64 BlockCount=0,VertexCountInPatch=0;double Maximum=0.0,MaximumGradient=0.0;
size_t Representative=I;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FHighDetailBlock& A=HighDetailBlocks[Current];
++BlockCount;VertexCountInPatch+=A.Vertices;
MaximumGradient=std::max(MaximumGradient,A.MaximumGradient);
if(A.Maximum>Maximum){Maximum=A.Maximum;Representative=Current;}
for(size_t J=0;J<HighDetailBlocks.size();++J)
{
if(HighDetailVisited[J])continue;
int32 Manhattan=0;
for(int32 Axis=0;Axis<3;++Axis)
Manhattan+=std::abs(A.Key[Axis]-HighDetailBlocks[J].Key[Axis]);
if(Manhattan==1){HighDetailVisited[J]=1;Pending.push_back(J);}
}
}
// Large relief is valid when it changes smoothly over multiple cells. Flag
// only connected high-amplitude patches whose measured slope is alias-prone.
if(BlockCount<3||VertexCountInPatch<48||MaximumGradient<=0.55)continue;
++Result.DetailDisplacementPatches;
if(bPrintPatches&&Result.DetailDisplacementPatches<=8)
{
const auto& Sample=HighDetailBlocks[Representative];
std::printf("[MeshDetailDisplacementPatch] level=0 tile=(%d,%d,%d) connected_8vox_blocks=%llu vertices=%llu max_displacement=%.3f vox max_gradient=%.4f vox_per_vox sample=(%.3f,%.3f,%.3f)\n",
Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(VertexCountInPatch),Maximum,MaximumGradient,
Sample.Position[0],Sample.Position[1],Sample.Position[2]);
}
}
struct FBadFieldBlock
{FBlockKey Key{};uint64 Vertices=0,BadVertices=0;double Share=0.0,MaximumShift=0.0,
MaximumResidual=0.0;std::array<double,3> Position{};};
std::vector<FBadFieldBlock> BadFieldBlocks;
for(const auto& [Key,Block]:FieldBlocks)
{
if(Block.Vertices<12||Block.BadVertices<6)continue;
const double Share=static_cast<double>(Block.BadVertices)/Block.Vertices;
if(Share<0.25)continue;
BadFieldBlocks.push_back({Key,Block.Vertices,Block.BadVertices,Share,
Block.MaximumShift,Block.MaximumResidual,Block.Position});
}
std::vector<uint8> BadFieldVisited(BadFieldBlocks.size(),0);
for(size_t I=0;I<BadFieldBlocks.size();++I)
{
if(BadFieldVisited[I])continue;
std::vector<size_t> Pending{I};BadFieldVisited[I]=1;
uint64 BlockCount=0,BadVertexCount=0;double MaxShift=0.0,MaxResidual=0.0;
size_t Representative=I;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FBadFieldBlock& A=BadFieldBlocks[Current];
++BlockCount;BadVertexCount+=A.BadVertices;
MaxShift=std::max(MaxShift,A.MaximumShift);
MaxResidual=std::max(MaxResidual,A.MaximumResidual);
if(A.MaximumShift>=MaxShift||A.MaximumResidual>=MaxResidual)Representative=Current;
for(size_t J=0;J<BadFieldBlocks.size();++J)
{
if(BadFieldVisited[J]||A.Key[0]!=BadFieldBlocks[J].Key[0])continue;
int32 Manhattan=0;
for(int32 Axis=1;Axis<4;++Axis)
Manhattan+=std::abs(A.Key[Axis]-BadFieldBlocks[J].Key[Axis]);
if(Manhattan==1){BadFieldVisited[J]=1;Pending.push_back(J);}
}
}
if(BlockCount<2||BadVertexCount<24)continue;
++Result.FieldMismatchPatches;
if(bPrintPatches&&Result.FieldMismatchPatches<=8)
{
const FBadFieldBlock& Sample=BadFieldBlocks[Representative];
std::printf("[MeshFieldMismatchPatch] level=%d tile=(%d,%d,%d) connected_8vox_blocks=%llu bad_edges=%llu max_analytic_shift=%.3f vox max_source_residual=%.3f vox sample=(%.3f,%.3f,%.3f)\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(BadVertexCount),MaxShift,MaxResidual,
Sample.Position[0],Sample.Position[1],Sample.Position[2]);
}
}
struct FBadGradientFallbackBlock
{FBlockKey Key{};uint64 Vertices=0,BadVertices=0,BadSamples=0;
double MaximumError=0.0;std::array<double,3> Position{};};
std::vector<FBadGradientFallbackBlock> BadGradientFallbackBlocks;
for(const auto& [Key,Block]:GradientFallbackBlocks)
{
if(Block.Vertices<12||Block.BadVertices<6)continue;
if(static_cast<double>(Block.BadVertices)/Block.Vertices<0.25)continue;
BadGradientFallbackBlocks.push_back({Key,Block.Vertices,Block.BadVertices,
Block.BadSamples,Block.MaximumError,Block.Position});
}
std::vector<uint8> GradientFallbackVisited(BadGradientFallbackBlocks.size(),0);
for(size_t I=0;I<BadGradientFallbackBlocks.size();++I)
{
if(GradientFallbackVisited[I])continue;
std::vector<size_t> Pending{I};GradientFallbackVisited[I]=1;
uint64 BlockCount=0,BadVertexCount=0,BadSamples=0;double MaximumError=0.0;
size_t Representative=I;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FBadGradientFallbackBlock& A=BadGradientFallbackBlocks[Current];
++BlockCount;BadVertexCount+=A.BadVertices;BadSamples+=A.BadSamples;
MaximumError=std::max(MaximumError,A.MaximumError);
if(A.MaximumError>=MaximumError)Representative=Current;
for(size_t J=0;J<BadGradientFallbackBlocks.size();++J)
{
if(GradientFallbackVisited[J]
||A.Key[0]!=BadGradientFallbackBlocks[J].Key[0])continue;
int32 Manhattan=0;
for(int32 Axis=1;Axis<4;++Axis)
Manhattan+=std::abs(A.Key[Axis]-BadGradientFallbackBlocks[J].Key[Axis]);
if(Manhattan==1)
{GradientFallbackVisited[J]=1;Pending.push_back(J);}
}
}
if(BlockCount<2||BadVertexCount<24)continue;
++Result.GradientFallbackPatches;Result.GradientFallbackSamples+=BadSamples;
if(bPrintPatches&&Result.GradientFallbackPatches<=8)
{
const auto& Sample=BadGradientFallbackBlocks[Representative];
std::printf("[MeshGradientFallbackPatch] level=%d tile=(%d,%d,%d) connected_8vox_blocks=%llu vertices=%llu fallback_gradient_samples=%llu max_distance_error=%.3f vox sample=(%.3f,%.3f,%.3f)\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(BadVertexCount),
static_cast<unsigned long long>(BadSamples),MaximumError,
Sample.Position[0],Sample.Position[1],Sample.Position[2]);
}
}
struct FBadNormalBlock
{FBlockKey Key{};uint64 Vertices=0,BadVertices=0;double MinimumAgreement=1.0;
std::array<double,3> Position{},MeshNormal{};};
std::vector<FBadNormalBlock> BadNormalBlocks;
for(const auto& [Key,Block]:NormalBlocks)
{
if(Block.Vertices<12||Block.BadVertices<6)continue;
if(static_cast<double>(Block.BadVertices)/Block.Vertices<0.25)continue;
BadNormalBlocks.push_back({Key,Block.Vertices,Block.BadVertices,
Block.MinimumAgreement,Block.Position,Block.MeshNormal});
}
std::vector<uint8> BadNormalVisited(BadNormalBlocks.size(),0);
for(size_t I=0;I<BadNormalBlocks.size();++I)
{
if(BadNormalVisited[I])continue;
std::vector<size_t> Pending{I};BadNormalVisited[I]=1;
uint64 BlockCount=0,BadVertexCount=0;double MinAgreement=1.0;size_t Representative=I;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FBadNormalBlock& A=BadNormalBlocks[Current];
++BlockCount;BadVertexCount+=A.BadVertices;
MinAgreement=std::min(MinAgreement,A.MinimumAgreement);
if(A.MinimumAgreement<BadNormalBlocks[Representative].MinimumAgreement)
Representative=Current;
for(size_t J=0;J<BadNormalBlocks.size();++J)
{
if(BadNormalVisited[J]||A.Key[0]!=BadNormalBlocks[J].Key[0])continue;
int32 Manhattan=0;
for(int32 Axis=1;Axis<4;++Axis)
Manhattan+=std::abs(A.Key[Axis]-BadNormalBlocks[J].Key[Axis]);
if(Manhattan==1){BadNormalVisited[J]=1;Pending.push_back(J);}
}
}
if(BlockCount<2||BadVertexCount<24)continue;
++Result.NormalMismatchPatches;
if(bPrintPatches&&Result.NormalMismatchPatches<=8)
{
const auto& Sample=BadNormalBlocks[Representative];
std::printf("[MeshNormalMismatchPatch] level=%d tile=(%d,%d,%d) connected_8vox_blocks=%llu bad_normals=%llu min_field_normal_dot=%.3f sample=(%.3f,%.3f,%.3f)\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(BadVertexCount),MinAgreement,
Sample.Position[0],Sample.Position[1],Sample.Position[2]);
double EdgeA[3],EdgeB[3];
for(int32 Axis=0;Axis<3;++Axis)
{
EdgeA[Axis]=(&Origin.X)[Axis]
+std::floor((Sample.Position[Axis]-(&Origin.X)[Axis])/Step)*Step;
EdgeB[Axis]=EdgeA[Axis];
}
EdgeB[Sample.Key[0]]+=Step;
double GradPacked[2][3]{},GradExact[2][3]{};
for(int32 Endpoint=0;Endpoint<2;++Endpoint)
{
const double* P=Endpoint?EdgeB:EdgeA;
for(int32 Axis=0;Axis<3;++Axis)
{
double Minus[3]={P[0],P[1],P[2]},Plus[3]={P[0],P[1],P[2]};
Minus[Axis]-=1.0;Plus[Axis]+=1.0;
GradPacked[Endpoint][Axis]=Shape.densityAt({Plus[0],Plus[1],Plus[2]})
-Shape.densityAt({Minus[0],Minus[1],Minus[2]});
for(int32 A=0;A<3;++A){Minus[A]+=0.013;Plus[A]+=0.013;}
GradExact[Endpoint][Axis]=Shape.unclampedDensityAt(
{Plus[0],Plus[1],Plus[2]})
-Shape.unclampedDensityAt({Minus[0],Minus[1],Minus[2]});
}
}
const double T=std::clamp(Sample.Position[Sample.Key[0]]-EdgeA[Sample.Key[0]],0.0,1.0);
double PackedInterpolated[3]{},ExactInterpolated[3]{};
for(int32 Axis=0;Axis<3;++Axis)
{
PackedInterpolated[Axis]=GradPacked[0][Axis]+T*(GradPacked[1][Axis]-GradPacked[0][Axis]);
ExactInterpolated[Axis]=GradExact[0][Axis]+T*(GradExact[1][Axis]-GradExact[0][Axis]);
}
const auto NormalDot=[](const double A[3],const double B[3])
{
const double AL=std::sqrt(A[0]*A[0]+A[1]*A[1]+A[2]*A[2]);
const double BL=std::sqrt(B[0]*B[0]+B[1]*B[1]+B[2]*B[2]);
return AL>1.0e-10&&BL>1.0e-10
?(A[0]*B[0]+A[1]*B[1]+A[2]*B[2])/(AL*BL):0.0;
};
std::printf("[MeshNormalProbe] t=%.3f edge_axis=%d mesh=(%.3f,%.3f,%.3f) packed_grid=(%.3f,%.3f,%.3f) exact_grid=(%.3f,%.3f,%.3f) packed_dot=%.3f exact_dot=%.3f endpoints=(%.0f,%.0f,%.0f)->(%.0f,%.0f,%.0f)\n",
T,Sample.Key[0],Sample.MeshNormal[0],Sample.MeshNormal[1],Sample.MeshNormal[2],
PackedInterpolated[0],PackedInterpolated[1],PackedInterpolated[2],
ExactInterpolated[0],ExactInterpolated[1],ExactInterpolated[2],
NormalDot(Sample.MeshNormal.data(),PackedInterpolated),
NormalDot(Sample.MeshNormal.data(),ExactInterpolated),
EdgeA[0],EdgeA[1],EdgeA[2],EdgeB[0],EdgeB[1],EdgeB[2]);
for(int32 Endpoint=0;Endpoint<2;++Endpoint)
for(int32 Axis=0;Axis<3;++Axis)
{
const double* P=Endpoint?EdgeB:EdgeA;
for(int32 Side=-1;Side<=1;Side+=2)
{
double Q[3]={P[0],P[1],P[2]};Q[Axis]+=Side;
const double Packed=Shape.densityAt({Q[0],Q[1],Q[2]});
Q[0]+=0.013;Q[1]+=0.013;Q[2]+=0.013;
const double Exact=Shape.unclampedDensityAt({Q[0],Q[1],Q[2]});
if(std::abs(Packed-Exact)>0.02)
std::printf("[MeshNormalProbeNode] endpoint=%d axis=%d side=%d packed=%.4f exact=%.4f delta=%.4f\n",
Endpoint,Axis,Side,Packed,Exact,Packed-Exact);
}
}
}
}
if(Tile.Key.Level==0&&Tile.Key.Coord.X==1
&&Tile.Key.Coord.Y==-16&&Tile.Key.Coord.Z==-3)
{
struct FConcentratedBlock
{FBlockKey Key{};uint64 Count=0;double TopOne=0.0,TopThree=0.0;
std::array<int32,3> Bins{};std::array<double,3> Position{};};
std::vector<FConcentratedBlock> ConcentratedBlocks;
for(const auto& [Key,Bins]:OffsetBlocks)
{
const uint64 Count=std::accumulate(Bins.begin(),Bins.end(),uint64{0});
if(Count<12)continue;
std::array<int32,256> Order{};
std::iota(Order.begin(),Order.end(),0);
std::partial_sort(Order.begin(),Order.begin()+3,Order.end(),
[&](int32 A,int32 B){return Bins[A]>Bins[B];});
const uint64 TopThree=Bins[Order[0]]+Bins[Order[1]]+Bins[Order[2]];
ConcentratedBlocks.push_back({Key,Count,
static_cast<double>(Bins[Order[0]])/Count,
static_cast<double>(TopThree)/Count,
{Order[0],Order[1],Order[2]},FirstPositionByBlock[Key]});
}
std::sort(ConcentratedBlocks.begin(),ConcentratedBlocks.end(),
[](const auto& A,const auto& B){return A.TopThree>B.TopThree;});
for(size_t I=0;I<std::min<size_t>(8,ConcentratedBlocks.size());++I)
{
const auto& B=ConcentratedBlocks[I];
std::printf("[MeshOffsetConcentration] tile=(1,-16,-3) axis=%d block=(%d,%d,%d) vertices=%llu top1=%.3f top3=%.3f bins=(%d,%d,%d) sample=(%.3f,%.3f,%.3f)\n",
B.Key[0],B.Key[1],B.Key[2],B.Key[3],
static_cast<unsigned long long>(B.Count),B.TopOne,B.TopThree,
B.Bins[0],B.Bins[1],B.Bins[2],
B.Position[0],B.Position[1],B.Position[2]);
}
}
struct FRepeatBlock
{FBlockKey Key{};int32 Bin=0;uint64 Count=0;double Share=0.0;
std::array<double,3> Position{},Normal{};};
std::vector<FRepeatBlock> RepeatBlocks;
for(const auto& [Key,Bins]:OffsetBlocks)
{
const uint64 Count=std::accumulate(Bins.begin(),Bins.end(),uint64{0});
if(Count<12)continue;
const auto Best=std::max_element(Bins.begin(),Bins.end());
const int32 Bin=static_cast<int32>(Best-Bins.begin());
const double Share=static_cast<double>(*Best)/Count;
if(Bin<80||Bin>176||Share<0.75)continue;
RepeatBlocks.push_back({Key,Bin,Count,Share,FirstPositionByBlock[Key],FirstNormalByBlock[Key]});
}
std::vector<uint8> Visited(RepeatBlocks.size(),0);
for(size_t I=0;I<RepeatBlocks.size();++I)
{
if(Visited[I])continue;
std::vector<size_t> Pending{I};Visited[I]=1;
uint64 BlockCount=0,VertexCountInPatch=0;double Dominance=0.0;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FRepeatBlock& A=RepeatBlocks[Current];
++BlockCount;VertexCountInPatch+=A.Count;Dominance=std::max(Dominance,A.Share);
for(size_t J=0;J<RepeatBlocks.size();++J)
{
if(Visited[J]||A.Key[0]!=RepeatBlocks[J].Key[0]
||std::abs(A.Bin-RepeatBlocks[J].Bin)>1)continue;
int32 Manhattan=0;
for(int32 Axis=1;Axis<4;++Axis)
Manhattan+=std::abs(A.Key[Axis]-RepeatBlocks[J].Key[Axis]);
if(Manhattan==1){Visited[J]=1;Pending.push_back(J);}
}
}
if(BlockCount<3||VertexCountInPatch<48)continue;
++Result.RepeatedOffsetPatches;
Result.MaximumPatchDominance=std::max(Result.MaximumPatchDominance,Dominance);
if(bPrintPatches&&Result.RepeatedOffsetPatches<=8)
{
const auto& P=RepeatBlocks[I].Position;const int32 Axis=RepeatBlocks[I].Key[0];
double EdgeA[3],EdgeB[3];
for(int32 A=0;A<3;++A)
{
const int32 Cell=static_cast<int32>(std::floor((P[A]-(&Origin.X)[A])/Step));
EdgeA[A]=(&Origin.X)[A]+Cell*Step;EdgeB[A]=EdgeA[A];
}
EdgeB[Axis]+=Step;
const double D0=Shape.densityAt({EdgeA[0],EdgeA[1],EdgeA[2]});
const double D1=Shape.densityAt({EdgeB[0],EdgeB[1],EdgeB[2]});
const double ExactD0=Shape.densityAt({EdgeA[0]+0.013,EdgeA[1]+0.013,EdgeA[2]+0.013});
const double ExactD1=Shape.densityAt({EdgeB[0]+0.013,EdgeB[1]+0.013,EdgeB[2]+0.013});
const double InterpolatedT=std::abs(D1-D0)>1.0e-9
?std::clamp(-D0/(D1-D0),0.0,1.0):0.5;
const double SourceDensity=Shape.densityAt({P[0],P[1],P[2]});
const auto& N=RepeatBlocks[I].Normal;
const double PlusNormal=Shape.densityAt({P[0]+N[0],P[1]+N[1],P[2]+N[2]});
const double MinusNormal=Shape.densityAt({P[0]-N[0],P[1]-N[1],P[2]-N[2]});
std::printf("[MeshLatticePatch] level=%d tile=(%d,%d,%d) connected_8vox_blocks=%llu edge_vertices=%llu dominant_share=%.3f midpoint_bin_cluster=1 axis=%d sample=(%.3f,%.3f,%.3f) offset=%.4f normal=(%.3f,%.3f,%.3f) endpoint_density=(%.4f,%.4f) analytic_probe=(%.4f,%.4f) predicted_t=%.4f source_density=%.4f normal_probe=(plus1=%.4f,minus1=%.4f)\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(VertexCountInPatch),Dominance,Axis,
P[0],P[1],P[2],(P[Axis]-EdgeA[Axis])/Step,N[0],N[1],N[2],D0,D1,
ExactD0,ExactD1,InterpolatedT,SourceDensity,PlusNormal,MinusNormal);
}
}
const size_t TriangleCount=Tile.Indices.size()/3;
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
if(A<SurfaceVertices&&B<SurfaceVertices&&C<SurfaceVertices)
{
if(Tile.Key.Level==0&&Tile.Key.Coord.X==1
&&Tile.Key.Coord.Y==-16&&Tile.Key.Coord.Z==-3)
{
const auto& PA=Tile.Vertices[A].Position;
const auto& PB=Tile.Vertices[B].Position;
const auto& PC=Tile.Vertices[C].Position;
const double V[3][3]={{PA[0]*4.0,PA[1]*4.0,PA[2]*4.0},
{PB[0]*4.0,PB[1]*4.0,PB[2]*4.0},
{PC[0]*4.0,PC[1]*4.0,PC[2]*4.0}};
const double Probe[4][3]={
{(V[0][0]+V[1][0]+V[2][0])/3.0,
(V[0][1]+V[1][1]+V[2][1])/3.0,
(V[0][2]+V[1][2]+V[2][2])/3.0},
{(V[0][0]+V[1][0])/2.0,(V[0][1]+V[1][1])/2.0,(V[0][2]+V[1][2])/2.0},
{(V[1][0]+V[2][0])/2.0,(V[1][1]+V[2][1])/2.0,(V[1][2]+V[2][2])/2.0},
{(V[2][0]+V[0][0])/2.0,(V[2][1]+V[0][1])/2.0,(V[2][2]+V[0][2])/2.0}};
for(const auto& Sample:Probe)
{
const double Residual=std::abs(Shape.unclampedDensityAt(
{Sample[0]+0.013,Sample[1]+0.013,Sample[2]+0.013}));
++RayTileInteriorSamples;RayTileInteriorResidualSum+=Residual;
if(Residual>0.125)++RayTileInteriorGt0125;
if(Residual>0.25)++RayTileInteriorGt025;
if(Residual>0.5)++RayTileInteriorGt05;
if(Residual>1.0)++RayTileInteriorGt1;
if(Residual>RayTileInteriorResidualMaximum)
{
RayTileInteriorResidualMaximum=Residual;
RayTileInteriorMaximumPosition={Sample[0],Sample[1],Sample[2]};
}
}
}
continue;
}
const uint8 SkirtFaces=T<Tile.TriangleSkirtFaceMasks.size()
?Tile.TriangleSkirtFaceMasks[T]:0x3f;
if((SkirtFaces&VisibleSkirtFaceMask)==0)
{++Result.HiddenSameLodSkirtTriangles;continue;}
++Result.SkirtTriangles;
const auto& PA=Tile.Vertices[A].Position;const auto& PB=Tile.Vertices[B].Position;
const auto& PC=Tile.Vertices[C].Position;
const VoxelForgeCore::Vec3d Center{
(static_cast<double>(PA[0])+PB[0]+PC[0])*4.0/3.0,
(static_cast<double>(PA[1])+PB[1]+PC[1])*4.0/3.0,
(static_cast<double>(PA[2])+PB[2]+PC[2])*4.0/3.0};
const double Density=Shape.densityAt(Center);
double AlternativeCenter[3]={0.0,0.0,0.0};
const uint32 TriangleIndices[3]={A,B,C};
for(uint32 Index:TriangleIndices)
for(int32 Axis=0;Axis<3;++Axis)
{
double Position=Tile.Vertices[Index].Position[Axis];
if(Index>=SurfaceVertices)
Position+=2.0*SkirtDepthMeters*Tile.Vertices[Index].Normal[Axis];
AlternativeCenter[Axis]+=Position*4.0/3.0;
}
const double AlternativeDensity=Shape.densityAt({
AlternativeCenter[0],AlternativeCenter[1],AlternativeCenter[2]});
double Normal[3]={0.0,0.0,0.0};
for(uint32 Index:TriangleIndices)if(Index>=SurfaceVertices)
for(int32 Axis=0;Axis<3;++Axis)Normal[Axis]+=Tile.Vertices[Index].Normal[Axis];
const double NormalLength=std::sqrt(Normal[0]*Normal[0]+Normal[1]*Normal[1]+Normal[2]*Normal[2]);
if(NormalLength>1.0e-8)for(double& Value:Normal)Value/=NormalLength;
const double Inward1=Shape.densityAt({Center.x-Normal[0],Center.y-Normal[1],Center.z-Normal[2]});
const double Inward2=Shape.densityAt({Center.x-Normal[0]*2.0,Center.y-Normal[1]*2.0,Center.z-Normal[2]*2.0});
double MaximumProbeDensity=Density;
const double ProbeWeights[10][3]={
{1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0},
{1.0/3.0,1.0/3.0,1.0/3.0},
{0.5,0.5,0.0},{0.0,0.5,0.5},{0.5,0.0,0.5},
{0.75,0.125,0.125},{0.125,0.75,0.125},{0.125,0.125,0.75}};
for(const auto& Weights:ProbeWeights)
{
const VoxelForgeCore::Vec3d Probe{
PA[0]*Weights[0]+PB[0]*Weights[1]+PC[0]*Weights[2],
PA[1]*Weights[0]+PB[1]*Weights[1]+PC[1]*Weights[2],
PA[2]*Weights[0]+PB[2]*Weights[1]+PC[2]*Weights[2]};
MaximumProbeDensity=std::max(MaximumProbeDensity,static_cast<double>(
Shape.densityAt({Probe.x*4.0,Probe.y*4.0,Probe.z*4.0})));
}
if(MaximumProbeDensity>0.25)
{
++Result.ExposedSkirtTriangles;
Result.MaximumAirSkirtDensity=std::max(
Result.MaximumAirSkirtDensity,MaximumProbeDensity);
if(AlternativeDensity<-0.25)++Result.ReverseSideSolidSkirtTriangles;
if(bPrintSkirts&&Result.ExposedSkirtTriangles<=8)
std::printf("[ExposedTileSkirt] level=%d tile=(%d,%d,%d) center=(%.2f,%.2f,%.2f) center_density=%.3f max_probe_density=%.3f reverse_density=%.3f inward=(%.3f,%.3f) normal=(%.3f,%.3f,%.3f)\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
Center.x,Center.y,Center.z,Density,MaximumProbeDensity,
AlternativeDensity,Inward1,Inward2,
Normal[0],Normal[1],Normal[2]);
}
}
if(Tile.Key.Level==0&&Tile.Key.Coord.X==1
&&Tile.Key.Coord.Y==-16&&Tile.Key.Coord.Z==-3)
{
std::printf("[MeshRayTileResidual] tile=(1,-16,-3) vertices=%llu mean=%.4f max=%.4f gt0.1=%llu gt0.25=%llu gt0.5=%llu max_vertex=(%.3f,%.3f,%.3f)\n",
static_cast<unsigned long long>(RayTileResidualSamples),
RayTileResidualSamples?RayTileResidualSum/RayTileResidualSamples:0.0,
RayTileResidualMaximum,
static_cast<unsigned long long>(RayTileResidualGt01),
static_cast<unsigned long long>(RayTileResidualGt025),
static_cast<unsigned long long>(RayTileResidualGt05),
RayTileResidualMaximumPosition[0],RayTileResidualMaximumPosition[1],
RayTileResidualMaximumPosition[2]);
std::printf("[MeshRayTileInteriorResidual] tile=(1,-16,-3) samples=%llu mean=%.4f max=%.4f gt0.125=%llu gt0.25=%llu gt0.5=%llu gt1=%llu max_probe=(%.3f,%.3f,%.3f)\n",
static_cast<unsigned long long>(RayTileInteriorSamples),
RayTileInteriorSamples?RayTileInteriorResidualSum/RayTileInteriorSamples:0.0,
RayTileInteriorResidualMaximum,
static_cast<unsigned long long>(RayTileInteriorGt0125),
static_cast<unsigned long long>(RayTileInteriorGt025),
static_cast<unsigned long long>(RayTileInteriorGt05),
static_cast<unsigned long long>(RayTileInteriorGt1),
RayTileInteriorMaximumPosition[0],RayTileInteriorMaximumPosition[1],
RayTileInteriorMaximumPosition[2]);
}
struct FBadCurvedEdgeRootBlock
{FBlockKey Key{};uint64 Vertices=0,BadVertices=0;double Share=0.0,MaximumError=0.0;
std::array<double,3> Position{};};
std::vector<FBadCurvedEdgeRootBlock> BadCurvedEdgeRootBlocks;
for(const auto& [Key,Block]:CurvedEdgeRootBlocks)
{
if(Block.Vertices<12||Block.BadVertices<6)continue;
const double Share=static_cast<double>(Block.BadVertices)/Block.Vertices;
if(Share<0.25)continue;
BadCurvedEdgeRootBlocks.push_back({Key,Block.Vertices,Block.BadVertices,Share,
Block.MaximumError,Block.Position});
}
std::vector<uint8> CurvedEdgeRootVisited(BadCurvedEdgeRootBlocks.size(),0);
for(size_t I=0;I<BadCurvedEdgeRootBlocks.size();++I)
{
if(CurvedEdgeRootVisited[I])continue;
std::vector<size_t> Pending{I};CurvedEdgeRootVisited[I]=1;
uint64 BlockCount=0,BadVertexCount=0;double MaximumError=0.0;size_t Representative=I;
while(!Pending.empty())
{
const size_t Current=Pending.back();Pending.pop_back();
const FBadCurvedEdgeRootBlock& A=BadCurvedEdgeRootBlocks[Current];
++BlockCount;BadVertexCount+=A.BadVertices;
if(A.MaximumError>MaximumError)
{MaximumError=A.MaximumError;Representative=Current;}
for(size_t J=0;J<BadCurvedEdgeRootBlocks.size();++J)
{
if(CurvedEdgeRootVisited[J]
||A.Key[0]!=BadCurvedEdgeRootBlocks[J].Key[0])continue;
int32 Manhattan=0;
for(int32 Axis=1;Axis<4;++Axis)
Manhattan+=std::abs(A.Key[Axis]-BadCurvedEdgeRootBlocks[J].Key[Axis]);
if(Manhattan==1)
{CurvedEdgeRootVisited[J]=1;Pending.push_back(J);}
}
}
if(BlockCount<2||BadVertexCount<24)continue;
++Result.CurvedEdgeRootPatches;
if(bPrintPatches&&Result.CurvedEdgeRootPatches<=8)
{
const FBadCurvedEdgeRootBlock& Sample=BadCurvedEdgeRootBlocks[Representative];
std::printf("[MeshCurvedEdgeRootPatch] level=0 tile=(%d,%d,%d) connected_8vox_blocks=%llu bad_vertices=%llu max_root_error=%.4f vox sample=(%.3f,%.3f,%.3f)\n",
Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(BlockCount),
static_cast<unsigned long long>(BadVertexCount),MaximumError,
Sample.Position[0],Sample.Position[1],Sample.Position[2]);
}
}
return Result;
}
FMeshSheetAudit AuditThinMeshSheets(const FStandaloneCpuTile& Tile,
const FVector& CameraVoxels,float Yaw,float Pitch,bool bPrintCandidates)
{
FMeshSheetAudit Result;
const size_t VertexCount=Tile.Vertices.size();
if(VertexCount==0||Tile.Indices.size()<3)return Result;
std::vector<uint32> Parent(VertexCount);
std::vector<uint8> Rank(VertexCount,0);
std::iota(Parent.begin(),Parent.end(),0u);
auto Find=[&](uint32 Value)
{
uint32 Root=Value;
while(Parent[Root]!=Root)Root=Parent[Root];
while(Parent[Value]!=Value)
{const uint32 Next=Parent[Value];Parent[Value]=Root;Value=Next;}
return Root;
};
auto Union=[&](uint32 A,uint32 B)
{
A=Find(A);B=Find(B);if(A==B)return;
if(Rank[A]<Rank[B])std::swap(A,B);
Parent[B]=A;if(Rank[A]==Rank[B])++Rank[A];
};
const size_t TriangleCount=Tile.Indices.size()/3;
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
Union(A,B);Union(B,C);
}
struct FComponent
{
uint64 Triangles=0,Vertices=0;
double Min[3]={std::numeric_limits<double>::max(),std::numeric_limits<double>::max(),std::numeric_limits<double>::max()};
double Max[3]={-std::numeric_limits<double>::max(),-std::numeric_limits<double>::max(),-std::numeric_limits<double>::max()};
double Sum[3]={0.0,0.0,0.0};
double Cov[6]={0.0,0.0,0.0,0.0,0.0,0.0};
};
std::vector<FComponent> Components(VertexCount);
for(size_t I=0;I<VertexCount;++I)
{
const uint32 Root=Find(static_cast<uint32>(I));
FComponent& C=Components[Root];++C.Vertices;
for(int32 A=0;A<3;++A)
{
const double P=Tile.Vertices[I].Position[A];
C.Min[A]=std::min(C.Min[A],P);C.Max[A]=std::max(C.Max[A],P);C.Sum[A]+=P;
}
}
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
++Components[Find(A)].Triangles;
}
for(size_t I=0;I<VertexCount;++I)
{
const uint32 Root=Find(static_cast<uint32>(I));
FComponent& C=Components[Root];
if(C.Vertices==0)continue;
const double P[3]={Tile.Vertices[I].Position[0],Tile.Vertices[I].Position[1],Tile.Vertices[I].Position[2]};
const double D[3]={P[0]-C.Sum[0]/C.Vertices,P[1]-C.Sum[1]/C.Vertices,P[2]-C.Sum[2]/C.Vertices};
C.Cov[0]+=D[0]*D[0];C.Cov[1]+=D[1]*D[1];C.Cov[2]+=D[2]*D[2];
C.Cov[3]+=D[0]*D[1];C.Cov[4]+=D[0]*D[2];C.Cov[5]+=D[1]*D[2];
}
const double Camera[3]={CameraVoxels.X*0.25,CameraVoxels.Y*0.25,CameraVoxels.Z*0.25};
const double CP=std::cos(Pitch),Forward[3]={std::sin(Yaw)*CP,std::cos(Yaw)*CP,std::sin(Pitch)};
const double Right[3]={std::cos(Yaw),-std::sin(Yaw),0.0};
const double Up[3]={-std::sin(Yaw)*std::sin(Pitch),-std::cos(Yaw)*std::sin(Pitch),std::cos(Pitch)};
for(size_t Root=0;Root<VertexCount;++Root)
{
FComponent& C=Components[Root];if(C.Triangles==0||C.Vertices==0)continue;
++Result.Components;
const double Extent[3]={C.Max[0]-C.Min[0],C.Max[1]-C.Min[1],C.Max[2]-C.Min[2]};
const double MaxExtent=std::max({Extent[0],Extent[1],Extent[2]})/0.25;
const bool bSmall=C.Triangles<=256&&MaxExtent<=20.0;
if(bSmall)++Result.SmallComponents;
if(!bSmall||C.Vertices<4)continue;
double A[3][3]={{C.Cov[0],C.Cov[3],C.Cov[4]},
{C.Cov[3],C.Cov[1],C.Cov[5]},{C.Cov[4],C.Cov[5],C.Cov[2]}};
for(int32 Sweep=0;Sweep<12;++Sweep)
{
int32 P=0,Q=1;
if(std::abs(A[0][2])>std::abs(A[P][Q])){P=0;Q=2;}
if(std::abs(A[1][2])>std::abs(A[P][Q])){P=1;Q=2;}
if(std::abs(A[P][Q])<1.0e-16)break;
const double Tau=(A[Q][Q]-A[P][P])/(2.0*A[P][Q]);
const double T=std::copysign(1.0,Tau)/(std::abs(Tau)+std::sqrt(1.0+Tau*Tau));
const double Cos=1.0/std::sqrt(1.0+T*T),Sin=T*Cos;
const double App=A[P][P],Aqq=A[Q][Q],Apq=A[P][Q];
A[P][P]=App-T*Apq;A[Q][Q]=Aqq+T*Apq;A[P][Q]=A[Q][P]=0.0;
for(int32 K=0;K<3;++K)if(K!=P&&K!=Q)
{
const double Akp=A[K][P],Akq=A[K][Q];
A[K][P]=A[P][K]=Cos*Akp-Sin*Akq;
A[K][Q]=A[Q][K]=Sin*Akp+Cos*Akq;
}
}
const double Variance=std::max(0.0,std::min({A[0][0],A[1][1],A[2][2]})/C.Vertices);
const double ThicknessVoxels=3.5*std::sqrt(Variance)/0.25;
const double Center[3]={C.Sum[0]/C.Vertices,C.Sum[1]/C.Vertices,C.Sum[2]/C.Vertices};
const double Relative[3]={Center[0]-Camera[0],Center[1]-Camera[1],Center[2]-Camera[2]};
const double Depth=Relative[0]*Forward[0]+Relative[1]*Forward[1]+Relative[2]*Forward[2];
const double ScreenX=Relative[0]*Right[0]+Relative[1]*Right[1]+Relative[2]*Right[2];
const double ScreenY=Relative[0]*Up[0]+Relative[1]*Up[1]+Relative[2]*Up[2];
const bool bInView=Depth>0.0&&Depth<=64.0&&std::abs(ScreenX)<0.924*Depth
&&std::abs(ScreenY)<0.5774*Depth;
if(!bInView)continue;
const FIntVector TileOrigin=Tile.Key.OriginVoxels();
const int32 TileMin[3]={TileOrigin.X,TileOrigin.Y,TileOrigin.Z};
const int32 TileMax[3]={TileOrigin.X+Tile.Key.ExtentVoxels(),
TileOrigin.Y+Tile.Key.ExtentVoxels(),TileOrigin.Z+Tile.Key.ExtentVoxels()};
bool bTouchesTileBoundary=false;
for(int32 Axis=0;Axis<3;++Axis)
{
const double MinVoxels=C.Min[Axis]*4.0,MaxVoxels=C.Max[Axis]*4.0;
bTouchesTileBoundary|=MinVoxels<=TileMin[Axis]+0.5
||MaxVoxels>=TileMax[Axis]-0.5;
}
if(bTouchesTileBoundary)++Result.BoundarySmallComponentsInView;
else ++Result.SmallComponentsInView;
if(bPrintCandidates&&!bTouchesTileBoundary&&Result.SmallComponentsInView<=8)
std::printf("[SmallMeshComponent] level=%d tile=(%d,%d,%d) tris=%llu size=(%.2f,%.2f,%.2f) vox pca_thickness=%.3f vox center=(%.2f,%.2f,%.2f)m\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(C.Triangles),Extent[0]/0.25,Extent[1]/0.25,
Extent[2]/0.25,ThicknessVoxels,Center[0],Center[1],Center[2]);
else if(bPrintCandidates&&bTouchesTileBoundary
&&Result.BoundarySmallComponentsInView<=8)
std::printf("[BoundaryMeshComponent] level=%d tile=(%d,%d,%d) tris=%llu size=(%.2f,%.2f,%.2f) vox pca_thickness=%.3f vox center=(%.2f,%.2f,%.2f)m\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(C.Triangles),Extent[0]/0.25,Extent[1]/0.25,
Extent[2]/0.25,ThicknessVoxels,Center[0],Center[1],Center[2]);
if(ThicknessVoxels>=1.0)continue;
++Result.ThinSheets;Result.MinimumThicknessVoxels=std::min(Result.MinimumThicknessVoxels,ThicknessVoxels);
Result.TrianglesInThinSheets+=C.Triangles;
if(bPrintCandidates&&Result.ThinSheets==1)
std::printf("[ThinMeshSheetCandidate] level=%d tile=(%d,%d,%d) tris=%llu size=(%.2f,%.2f,%.2f) vox pca_thickness=%.3f vox center=(%.2f,%.2f,%.2f)m\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(C.Triangles),Extent[0]/0.25,Extent[1]/0.25,Extent[2]/0.25,
ThicknessVoxels,Center[0],Center[1],Center[2]);
}
return Result;
}
struct FCoarsePanelAudit
{
uint64 Tiles=0,PlanarOpenComponents=0,OffSurfacePanels=0,Triangles=0;
double MaximumSourceErrorVoxels=0.0;
};
FCoarsePanelAudit AuditCoarseSurfacePanels(const FStandaloneCpuTile& Tile,
const VoxelForgeCore::World& Shape,const VoxelForgeCore::WorldConfiguration& Config,
bool bPrintCandidates)
{
FCoarsePanelAudit Result;
const size_t VertexCount=Tile.Vertices.size();
const size_t TriangleCount=Tile.Indices.size()/3;
if(Tile.Key.Level<1||VertexCount==0||TriangleCount==0)return Result;
std::vector<uint32> Parent(VertexCount);
std::vector<uint8> Rank(VertexCount,0);
std::iota(Parent.begin(),Parent.end(),0u);
const auto Find=[&](uint32 Value)
{
uint32 Root=Value;
while(Parent[Root]!=Root)Root=Parent[Root];
while(Parent[Value]!=Value)
{const uint32 Next=Parent[Value];Parent[Value]=Root;Value=Next;}
return Root;
};
const auto Union=[&](uint32 A,uint32 B)
{
A=Find(A);B=Find(B);if(A==B)return;
if(Rank[A]<Rank[B])std::swap(A,B);
Parent[B]=A;if(Rank[A]==Rank[B])++Rank[A];
};
const auto EdgeKey=[](uint32 A,uint32 B)
{if(A>B)std::swap(A,B);return (static_cast<uint64>(A)<<32)|B;};
std::unordered_map<uint64,uint8> EdgeUse;
EdgeUse.reserve(TriangleCount*3/2+1);
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
Union(A,B);Union(B,C);
for(const auto [U,V]:std::array<std::pair<uint32,uint32>,3>{{{A,B},{B,C},{C,A}}})
{
uint8& Count=EdgeUse[EdgeKey(U,V)];
if(Count<255)++Count;
}
}
struct FComponent
{
uint64 Triangles=0,InteriorFreeEdges=0,SourceSamples=0,OffSourceSamples=0;
double Normal[3]={0,0,0},NormalWeight=0,MaximumSourceError=0;
double WorstPosition[3]={0,0,0};
bool bWorstTriangleCentroid=false;
};
std::vector<FComponent> Components(VertexCount);
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
const uint32 Root=Find(A);FComponent& Stats=Components[Root];++Stats.Triangles;
const auto& PA=Tile.Vertices[A].Position;const auto& PB=Tile.Vertices[B].Position;
const auto& PC=Tile.Vertices[C].Position;
const double U[3]={PB[0]-PA[0],PB[1]-PA[1],PB[2]-PA[2]};
const double V[3]={PC[0]-PA[0],PC[1]-PA[1],PC[2]-PA[2]};
double N[3]={U[1]*V[2]-U[2]*V[1],U[2]*V[0]-U[0]*V[2],U[0]*V[1]-U[1]*V[0]};
const double Area2=std::sqrt(N[0]*N[0]+N[1]*N[1]+N[2]*N[2]);
if(Area2>1.0e-12)
{
for(int32 Axis=0;Axis<3;++Axis)Stats.Normal[Axis]+=N[Axis]/Area2*Area2;
Stats.NormalWeight+=Area2;
}
}
const FIntVector Origin=Tile.Key.OriginVoxels();
const double TileMin[3]={static_cast<double>(Origin.X),static_cast<double>(Origin.Y),static_cast<double>(Origin.Z)};
const double TileMax[3]={TileMin[0]+Tile.Key.ExtentVoxels(),TileMin[1]+Tile.Key.ExtentVoxels(),TileMin[2]+Tile.Key.ExtentVoxels()};
const auto IsTileBoundaryEdge=[&](uint32 A,uint32 B)
{
for(int32 Axis=0;Axis<3;++Axis)
{
const double PA=Tile.Vertices[A].Position[Axis]*4.0;
const double PB=Tile.Vertices[B].Position[Axis]*4.0;
if((std::abs(PA-TileMin[Axis])<0.75&&std::abs(PB-TileMin[Axis])<0.75)
||(std::abs(PA-TileMax[Axis])<0.75&&std::abs(PB-TileMax[Axis])<0.75))return true;
}
return false;
};
for(const auto& [Key,Count]:EdgeUse)
{
if(Count!=1)continue;
const uint32 A=static_cast<uint32>(Key>>32),B=static_cast<uint32>(Key);
if(A>=VertexCount||B>=VertexCount||IsTileBoundaryEdge(A,B))continue;
++Components[Find(A)].InteriorFreeEdges;
}
const int32 Extent=Tile.Key.ExtentVoxels();
const int32 Cells=Tile.Key.Level<Config.fullResolutionLodCount
?CHUNK_SIZE:std::max(1,Config.coarseTileCells);
const double Step=std::max(1,Extent/Cells);
const double ResidualLimit=std::max(2.0,Step*0.10);
std::vector<uint8> Candidate(VertexCount,0);
for(size_t Root=0;Root<VertexCount;++Root)
{
FComponent& Stats=Components[Root];
if(Stats.Triangles==0||Stats.Triangles>256||Stats.InteriorFreeEdges==0||Stats.NormalWeight<=0.0)continue;
const double NormalLength=std::sqrt(Stats.Normal[0]*Stats.Normal[0]
+Stats.Normal[1]*Stats.Normal[1]+Stats.Normal[2]*Stats.Normal[2]);
const double Coherence=NormalLength/Stats.NormalWeight;
if(Coherence<0.995)continue;
Candidate[Root]=1;++Result.PlanarOpenComponents;
}
if(Result.PlanarOpenComponents==0)return Result;
for(size_t Vertex=0;Vertex<VertexCount;++Vertex)
{
const uint32 Root=Find(static_cast<uint32>(Vertex));
if(!Candidate[Root])continue;
const auto& P=Tile.Vertices[Vertex].Position;
const double Error=std::abs(Shape.densityAt({P[0]*4.0,P[1]*4.0,P[2]*4.0}));
FComponent& Stats=Components[Root];++Stats.SourceSamples;
if(Error>Stats.MaximumSourceError)
{
Stats.MaximumSourceError=Error;
std::copy_n(P,3,Stats.WorstPosition);
Stats.bWorstTriangleCentroid=false;
}
if(Error>ResidualLimit)++Stats.OffSourceSamples;
}
for(size_t T=0;T<TriangleCount;++T)
{
const uint32 A=Tile.Indices[T*3],B=Tile.Indices[T*3+1],C=Tile.Indices[T*3+2];
if(A>=VertexCount||B>=VertexCount||C>=VertexCount)continue;
const uint32 Root=Find(A);if(!Candidate[Root])continue;
const auto& PA=Tile.Vertices[A].Position;const auto& PB=Tile.Vertices[B].Position;
const auto& PC=Tile.Vertices[C].Position;
const double Error=std::abs(Shape.densityAt({(PA[0]+PB[0]+PC[0])*4.0/3.0,
(PA[1]+PB[1]+PC[1])*4.0/3.0,(PA[2]+PB[2]+PC[2])*4.0/3.0}));
FComponent& Stats=Components[Root];++Stats.SourceSamples;
if(Error>Stats.MaximumSourceError)
{
Stats.MaximumSourceError=Error;
Stats.WorstPosition[0]=(PA[0]+PB[0]+PC[0])/3.0;
Stats.WorstPosition[1]=(PA[1]+PB[1]+PC[1])/3.0;
Stats.WorstPosition[2]=(PA[2]+PB[2]+PC[2])/3.0;
Stats.bWorstTriangleCentroid=true;
}
if(Error>ResidualLimit)++Stats.OffSourceSamples;
}
for(size_t Root=0;Root<VertexCount;++Root)
{
const FComponent& Stats=Components[Root];if(!Candidate[Root]||Stats.SourceSamples==0)continue;
const double OffShare=static_cast<double>(Stats.OffSourceSamples)/Stats.SourceSamples;
Result.MaximumSourceErrorVoxels=std::max(Result.MaximumSourceErrorVoxels,Stats.MaximumSourceError);
if(OffShare<0.25)continue;
++Result.OffSurfacePanels;Result.Triangles+=Stats.Triangles;
if(bPrintCandidates&&Result.OffSurfacePanels<=8)
std::printf("[CoarsePanelCandidate] lod=%d tile=(%d,%d,%d) triangles=%llu interior_free_edges=%llu source_error=%.3f vox off_share=%.1f%% limit=%.3f vox worst=(%.2f,%.2f,%.2f)m sample=%s\n",
Tile.Key.Level,Tile.Key.Coord.X,Tile.Key.Coord.Y,Tile.Key.Coord.Z,
static_cast<unsigned long long>(Stats.Triangles),
static_cast<unsigned long long>(Stats.InteriorFreeEdges),Stats.MaximumSourceError,
OffShare*100.0,ResidualLimit,
Stats.WorstPosition[0],Stats.WorstPosition[1],Stats.WorstPosition[2],
Stats.bWorstTriangleCentroid?"centroid":"vertex");
}
Result.Tiles=1;
return Result;
}
struct M4 { float M[4][4]{}; };
M4 Identity(){M4 R{};for(int I=0;I<4;++I)R.M[I][I]=1.0f;return R;}
M4 Transpose(M4 A){M4 B{};for(int I=0;I<4;++I)for(int J=0;J<4;++J)B.M[I][J]=A.M[J][I];return B;}
M4 Perspective(float Fov,float Aspect,float NearZ,float FarZ)
{
M4 R{};const float Y=1.0f/std::tan(Fov*0.5f);
R.M[0][0]=Y/Aspect;R.M[1][1]=Y;R.M[2][2]=FarZ/(FarZ-NearZ);
R.M[2][3]=1.0f;R.M[3][2]=-NearZ*FarZ/(FarZ-NearZ);return R;
}
M4 View(V3 Position,V3 Forward,V3 Right,V3 Up)
{
M4 R=Identity();
R.M[0][0]=Right.X;R.M[1][0]=Right.Y;R.M[2][0]=Right.Z;R.M[3][0]=-Dot(Right,Position);
R.M[0][1]=Up.X;R.M[1][1]=Up.Y;R.M[2][1]=Up.Z;R.M[3][1]=-Dot(Up,Position);
R.M[0][2]=Forward.X;R.M[1][2]=Forward.Y;R.M[2][2]=Forward.Z;R.M[3][2]=-Dot(Forward,Position);
return R;
}
struct FGpuVertex { float Position[3]; float Normal[3]; };
struct FConstants
{
M4 ViewProjection;
float Camera[3]; float FogStart;
float Forward[3]; float FogEnd;
float LightDirection[3]; float Ambient;
float Padding[4];
};
constexpr int32 MaxLevels=8;
struct FStandaloneBatchKey
{
int32 Level=0,X=0,Y=0,Z=0;
bool operator==(const FStandaloneBatchKey& O)const
{return Level==O.Level&&X==O.X&&Y==O.Y&&Z==O.Z;}
};
struct FStandaloneBatchKeyHash
{
size_t operator()(const FStandaloneBatchKey& K)const noexcept
{
uint64 H=static_cast<uint32>(K.Level);
H=(H*0x9e3779b185ebca87ull)^static_cast<uint32>(K.X);
H=(H*0x9e3779b185ebca87ull)^static_cast<uint32>(K.Y);
H=(H*0x9e3779b185ebca87ull)^static_cast<uint32>(K.Z);
return static_cast<size_t>(H^(H>>32));
}
};
struct FResidentTileMesh
{
std::vector<FStandaloneCpuVertex> Vertices;
std::vector<uint32> Indices;
std::vector<uint8> TriangleSkirtFaceMasks;
uint8 ActiveSkirtFaceMask=0x3f;
uint64 Samples=0;
double WorkerSeconds=0.0;
};
struct FStreamingGpuBatch
{
ID3D11Buffer* VertexBuffer=nullptr;
ID3D11Buffer* IndexBuffer=nullptr;
UINT IndexCount=0;
uint64 VertexCount=0;
};
struct FCrossingWork
{
uint64 SubmittedJobs=0;
uint64 PendingJobs=0;
uint64 FinishedJobs=0;
uint64 CancelledQueuedJobs=0;
uint64 StaleResults=0;
uint64 Tiles=0;
uint64 Samples=0;
double WorkerSeconds=0.0;
double CorePageSeconds=0.0;
double CorePageWorkerSeconds=0.0;
uint64 PageCoveredTiles=0;
uint64 PageRegions=0;
uint64 PageLatticeNodes=0;
FVoxelTileKey NearestNewTile{};
double NearestReadySeconds=-1.0;
bool bHasNearestNewTile=false;
uint64 TilesByLevel[MaxLevels+1]{};
uint64 SamplesByLevel[MaxLevels+1]{};
double WorkerSecondsByLevel[MaxLevels+1]{};
double WallSeconds=0.0;
std::chrono::steady_clock::time_point StartTime{};
bool bReported=false;
};
struct FGpuFarTile
{
ID3D11Buffer* VertexBuffer=nullptr;
ID3D11Buffer* IndexBuffer=nullptr;
ID3D11Buffer* IndirectArgs=nullptr;
ID3D11Buffer* ConnectorVertexBuffer=nullptr;
ID3D11Buffer* ConnectorIndexBuffer=nullptr;
ID3D11Query* CompletionEvent=nullptr;
VoxelForgeGpuFarViewer::GpuTimingQueries TimingQueries{};
uint64 VertexCapacityBytes=0;
uint32 OutputSlot=0,IndirectArgsByteOffset=0,BatchIndex=UINT32_MAX;
double GpuDispatchMs=0.0;
bool bGpuComplete=false;
bool bTimingResolved=false;
};
struct FGpuFarBatch
{
ID3D11Query* CompletionEvent=nullptr;
VoxelForgeGpuFarViewer::GpuTimingQueries TimingQueries{};
uint32 TileCount=0;
uint64 TimestampFrequency=0;
double GpuDispatchMs=0.0;
std::chrono::steady_clock::time_point SubmittedAt{};
bool bGpuComplete=false,bTimingResolved=false;
};
uint64 HashStandaloneFile(const std::string& Path)
{
std::ifstream File(Path,std::ios::binary);
if(!File)return 0;
uint64 Hash=14695981039346656037ull;
char Buffer[65536];
while(File)
{
File.read(Buffer,sizeof(Buffer));
const std::streamsize Count=File.gcount();
for(std::streamsize I=0;I<Count;++I)
{
Hash^=static_cast<uint8>(Buffer[I]);
Hash*=1099511628211ull;
}
}
return Hash;
}
FStandaloneBatchKey BatchForTile(const FVoxelTileKey& Tile)
{
return {Tile.Level,VoxelClipmapDesiredTiles::FloorDiv(Tile.Coord.X,8),
VoxelClipmapDesiredTiles::FloorDiv(Tile.Coord.Y,8),Tile.Coord.Z};
}
bool PrepareStandaloneDensityWorld(FStandaloneOwnerWorld& World,int32 Seed,
bool bRoundTunnels,bool bEnhancedWalls,std::string& Error)
{
World.Generator.reset();World.Manager.reset();
World.Settings->Seed=Seed;World.Seed=Seed;
// Keep the owner's walkable rooms, tunnels, and strate passages intact. The research
// round field composes as additional air after the owner field, so it can widen/connect
// spaces but cannot remove the authored entrance-to-exit route.
World.Manager=std::make_unique<UVoxelStrateManager>();
if(!World.Manager->Initialize(World.Settings.get(),Seed))
{Error="standalone copied strate manager failed while applying viewer settings";return false;}
World.Generator=std::make_unique<UVoxelGenerator>();
World.Generator->InitializeSettings(World.Settings.get());
World.Generator->SetStrateManager(World.Manager.get());
World.Generator->bStandaloneResearchRoundTunnels=bRoundTunnels;
World.Generator->bStandaloneResearchEnhancedWalls=bEnhancedWalls;
return true;
}
struct FApp
{
HWND Window=nullptr;
ID3D11Device* Device=nullptr;
ID3D11DeviceContext* Context=nullptr;
IDXGISwapChain* SwapChain=nullptr;
ID3D11RenderTargetView* RenderTarget=nullptr;
ID3D11DepthStencilView* DepthView=nullptr;
ID3D11VertexShader* VertexShader=nullptr;
ID3D11PixelShader* PixelShader=nullptr;
ID3D11InputLayout* InputLayout=nullptr;
ID3D11Buffer* Constants=nullptr;
ID3D11RasterizerState* SolidRasterizer=nullptr;
ID3D11RasterizerState* WireRasterizer=nullptr;
std::shared_ptr<FStandaloneOwnerWorld> World;
VoxelForgeCore::ResolvedWorldSnapshot Snapshot;
std::unique_ptr<VoxelForgeCore::World> ShapeWorld;
std::unique_ptr<VoxelForgeCore::World> PendingFullShapeWorld;
FStandaloneCoreScheduler CoreScheduler;
std::unique_ptr<FStandaloneStreamingGenerator> Streamer;
std::thread FullShapeBuildThread;
std::atomic<bool> bFullShapeBuildFinished{false};
bool bFullShapeBuildSucceeded=false;
std::string FullShapeBuildError;
std::chrono::steady_clock::time_point FullShapeBuildStart{};
FStandaloneMeshCache MeshCache;
std::string DataPath;
VFJson::Value OwnerJsonRoot;
bool bHasCameraOverride=false;
V3 CameraPositionOverride{};
float CameraYawOverride=0.0f,CameraPitchOverride=0.0f;
std::unordered_map<FVoxelTileKey,FResidentTileMesh,FStandaloneTileKeyHash> ResidentTiles;
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> DeferredLeaverTiles;
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> DesiredTileSet;
std::unordered_map<FStandaloneBatchKey,std::vector<FVoxelTileKey>,FStandaloneBatchKeyHash> BatchMembers;
std::unordered_map<FStandaloneBatchKey,FStreamingGpuBatch,FStandaloneBatchKeyHash> StreamingBatches;
std::unordered_map<FVoxelTileKey,FGpuFarTile,FStandaloneTileKeyHash> GpuFarTiles;
std::vector<FGpuFarBatch> GpuFarBatches;
std::deque<FVoxelTileKey> GpuFarQueue;
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> GpuFarQueued;
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> GpuFarEligibleTiles;
std::unordered_set<FStandaloneBatchKey,FStandaloneBatchKeyHash> DirtyBatchSet;
std::unordered_map<uint64,FCrossingWork> CrossingWork;
std::vector<FVoxelTileKey> DesiredTiles;
std::vector<FVoxelTileKey> InitialNeighborhoodTiles;
int32 DesiredByLevel[MaxLevels+1]{};
uint64 GeneratedByLevel[MaxLevels+1]{};
uint64 SamplesByLevel[MaxLevels+1]{};
double WorkerSecondsByLevel[MaxLevels+1]{};
uint64 ProfileCyclesByLevel[MaxLevels+1][VoxelDensityProfile::BucketCount]{};
std::vector<double> TileSecondsByLevel[MaxLevels+1];
uint64 CrossingIndex=0;
bool bGenerationRunning=false;
bool bRebuildPending=false;
bool bParityChecked=false;
bool bRoundTunnels=false;
bool bRoundTunnelEnhanced=true;
bool bShapeWorld=false;
bool bShapePipelineActive=false;
bool bNeighborhoodReadyReported=false;
bool bShapeAuditOnly=false;
bool bShapeCompare=false;
bool bFarShapeStagePending=false;
bool bGpuFarEnabled=false;
bool bGpuFarAuditEnabled=false;
bool bGpuFarAuditReported=false;
std::unique_ptr<FFarSurvivalAudit> GpuFarAudit;
bool bGpuFarFirstTileReported=false;
std::filesystem::path GpuFarShaderPath;
double GpuFarEnqueueWallSeconds=0.0;
uint64 GpuFarTilesSubmitted=0;
double GpuFarGpuDispatchMs=0.0;
double GpuFarGpuDispatchMaxMs=0.0;
double GpuFarSubmissionSpanMs=0.0,GpuFarSubmissionSpanMaxMs=0.0;
uint64 GpuFarLocalMemoryPeakBytes=0,GpuFarLocalMemoryBudgetBytes=0;
double GpuFarPoolReserveMs=0.0;
uint64 GpuFarSubmissionBatches=0;
uint32 GpuFarMaxTilesPerSubmissionBatch=0;
uint32 GpuFarOutputCapacitySlots=0,GpuFarNextOutputSlot=0;
std::vector<uint32> GpuFarFreeOutputSlots;
std::unordered_map<FVoxelTileKey,VoxelForgeCore::FarFieldTileInput,FStandaloneTileKeyHash> GpuFarPreparedInputs;
std::unordered_map<FVoxelTileKey,std::string,FStandaloneTileKeyHash> GpuFarPreparationErrors;
double GpuFarPreparationWallMs=0.0,GpuFarPreparationWorkerMs=0.0;
uint64 GpuFarPumpCalls=0,GpuFarCompletionPolls=0;
double GpuFarFirstPumpMs=-1.0,GpuFarLastPumpMs=-1.0;
double GpuFarFirstSubmitMs=-1.0,GpuFarLastSubmitMs=-1.0;
double GpuFarFirstCompletionPollMs=-1.0,GpuFarLastCompletionPollMs=-1.0;
double GpuFarPumpWallMs=0.0,GpuFarPumpMaxWallMs=0.0;
double GpuFarPumpGapMs=0.0,GpuFarPumpGapMaxMs=0.0;
std::chrono::steady_clock::time_point LastGpuFarPumpAt{};
std::chrono::steady_clock::time_point LastDrawEndAt{};
VoxelForgeCore::DetailVariant ShapeDetailVariant=VoxelForgeCore::DetailVariant::coherent;
bool bWireframe=false;
bool bCaptured=false;
bool bAutoCaptureWritten=false;
bool bFullDetailReported=false;
bool bInitialClipmapReported=false;
bool bProfileAttribution=false;
bool bProfileDetailBand=false;
bool bCompareEvaluators=false;
bool bParityOnly=false;
bool bDensityHash=false;
int32 FlightTargetCrossings=0;
int32 FlightObservedCrossings=0;
uint64 FlightStartCrossingIndex=0;
float FlightSpeedMps=16.0f;
bool bFlightStarted=false;
bool bFlightFinished=false;
bool bFlightClosePosted=false;
bool bFlightCrossingsValid=true;
V3 FlightStartPosition{};
std::chrono::steady_clock::time_point FlightStartTime{};
bool bCaptureAfterClipmap=false;
bool bQuitAfterClipmap=false;
bool bPrintedClipOverride=false;
bool bForceGenerate=false;
std::string CapturePath;
std::string MeshCachePath;
std::chrono::steady_clock::time_point ColdProcessStart{};
std::chrono::steady_clock::time_point GenerationStart{};
bool bShowLevel[MaxLevels+1]={true,true,true,true,true,true,true,true,true};
bool Keys[256]{};
int32 Seed=0;
int32 WorkerCount=8;
int32 ClipRadius=3;
int32 MaxClipLevelOverride=-1;
int32 CaptureTileLimit=0;
int32 Width=1280,Height=800;
float Yaw=0.0f,Pitch=0.0f,MoveSpeed=8.0f;
V3 Position{};
POINT LastMouse{};
std::chrono::steady_clock::time_point PreviousFrame=std::chrono::steady_clock::now();
double FrameMs=0.0;
uint64 TotalVertices=0;
uint64 TotalIndices=0;
FIntVector BuildTargetChunk=FIntVector::ZeroValue;
int32 MaxBatchUploadsPerFrame=4;
double BatchUploadBudgetMilliseconds=2.0;
~FApp(){
StopGeneration(true);ReleaseMeshes();
if(SolidRasterizer)SolidRasterizer->Release();if(WireRasterizer)WireRasterizer->Release();
if(Constants)Constants->Release();if(InputLayout)InputLayout->Release();
if(VertexShader)VertexShader->Release();if(PixelShader)PixelShader->Release();
if(RenderTarget)RenderTarget->Release();if(DepthView)DepthView->Release();
if(SwapChain)SwapChain->Release();if(Context)Context->Release();if(Device)Device->Release();
}
static void ReleaseGpuFarTile(FGpuFarTile& Tile)
{
if(Tile.VertexBuffer)Tile.VertexBuffer->Release();
if(Tile.IndexBuffer)Tile.IndexBuffer->Release();
if(Tile.IndirectArgs)Tile.IndirectArgs->Release();
if(Tile.ConnectorVertexBuffer)Tile.ConnectorVertexBuffer->Release();
if(Tile.ConnectorIndexBuffer)Tile.ConnectorIndexBuffer->Release();
if(Tile.CompletionEvent)Tile.CompletionEvent->Release();
if(Tile.TimingQueries.start)Tile.TimingQueries.start->Release();
if(Tile.TimingQueries.end)Tile.TimingQueries.end->Release();
if(Tile.TimingQueries.disjoint)Tile.TimingQueries.disjoint->Release();
Tile={};
}
static void ReleaseGpuFarBatch(FGpuFarBatch& Batch)
{
if(Batch.CompletionEvent)Batch.CompletionEvent->Release();
if(Batch.TimingQueries.start)Batch.TimingQueries.start->Release();
if(Batch.TimingQueries.end)Batch.TimingQueries.end->Release();
if(Batch.TimingQueries.disjoint)Batch.TimingQueries.disjoint->Release();
Batch={};
}
void SampleGpuFarMemory()
{
if(!bGpuFarEnabled||!Device||!Context)return;
uint64 Usage=0,Budget=0;std::string Error;
if(VoxelForgeGpuFarViewer::QueryFarGpuMemory(Device,Context,GpuFarShaderPath,
Usage,Budget,Error))
{
GpuFarLocalMemoryPeakBytes=std::max(GpuFarLocalMemoryPeakBytes,Usage);
GpuFarLocalMemoryBudgetBytes=Budget;
}
}
void ReleaseMeshes()
{
for(auto& Pair:StreamingBatches)
{
if(Pair.second.VertexBuffer)Pair.second.VertexBuffer->Release();
if(Pair.second.IndexBuffer)Pair.second.IndexBuffer->Release();
}
StreamingBatches.clear();BatchMembers.clear();ResidentTiles.clear();
for(auto& Pair:GpuFarTiles)
ReleaseGpuFarTile(Pair.second);
GpuFarTiles.clear();
for(FGpuFarBatch& Batch:GpuFarBatches)ReleaseGpuFarBatch(Batch);
GpuFarBatches.clear();GpuFarQueue.clear();GpuFarQueued.clear();GpuFarEligibleTiles.clear();
GpuFarFreeOutputSlots.clear();GpuFarNextOutputSlot=0;
GpuFarPreparedInputs.clear();GpuFarPreparationErrors.clear();
GpuFarPreparationWallMs=0.0;GpuFarPreparationWorkerMs=0.0;
GpuFarPumpCalls=0;GpuFarCompletionPolls=0;
GpuFarFirstPumpMs=GpuFarLastPumpMs=GpuFarFirstSubmitMs=GpuFarLastSubmitMs=-1.0;
GpuFarFirstCompletionPollMs=GpuFarLastCompletionPollMs=-1.0;
GpuFarPumpWallMs=GpuFarPumpMaxWallMs=GpuFarPumpGapMs=GpuFarPumpGapMaxMs=0.0;
LastGpuFarPumpAt={};
LastDrawEndAt={};
GpuFarAudit.reset();bGpuFarAuditReported=false;
GpuFarTilesSubmitted=0;GpuFarEnqueueWallSeconds=0.0;GpuFarGpuDispatchMs=0.0;
GpuFarGpuDispatchMaxMs=0.0;GpuFarSubmissionSpanMs=0.0;GpuFarSubmissionSpanMaxMs=0.0;
GpuFarLocalMemoryPeakBytes=0;GpuFarLocalMemoryBudgetBytes=0;
bGpuFarFirstTileReported=false;
GpuFarPoolReserveMs=0.0;
GpuFarSubmissionBatches=0;GpuFarMaxTilesPerSubmissionBatch=0;
DirtyBatchSet.clear();DesiredTiles.clear();DesiredTileSet.clear();CrossingWork.clear();
DeferredLeaverTiles.clear();
for(int32 I=0;I<=MaxLevels;++I)
{DesiredByLevel[I]=0;GeneratedByLevel[I]=0;SamplesByLevel[I]=0;WorkerSecondsByLevel[I]=0.0;
std::fill(std::begin(ProfileCyclesByLevel[I]),std::end(ProfileCyclesByLevel[I]),0);
TileSecondsByLevel[I].clear();}
TotalVertices=0;TotalIndices=0;
}
void StopGeneration(bool bCancel=false)
{
(void)bCancel;
if(Streamer)Streamer->Stop();
Streamer.reset();
if(FullShapeBuildThread.joinable())FullShapeBuildThread.join();
PendingFullShapeWorld.reset();
bFullShapeBuildFinished.store(false,std::memory_order_relaxed);
bFullShapeBuildSucceeded=false;
FullShapeBuildError.clear();
InitialNeighborhoodTiles.clear();
bShapePipelineActive=false;
bNeighborhoodReadyReported=false;
bFarShapeStagePending=false;
bGenerationRunning=false;
}
V3 Forward() const
{return Normalize({std::sin(Yaw)*std::cos(Pitch),std::cos(Yaw)*std::cos(Pitch),std::sin(Pitch)});}
FIntVector CameraChunk() const
{return StandaloneWorldMesher::CameraChunk(FVector(Position.X*4.0,Position.Y*4.0,Position.Z*4.0));}
bool NeedsRecenter(const FIntVector& Center) const
{
return CameraChunk()!=Center;
}
bool MakeBuffer(ID3D11Buffer** Out,const void* Data,size_t Bytes,UINT Bind)
{
if(Bytes==0||Bytes>std::numeric_limits<UINT>::max())return false;
D3D11_BUFFER_DESC Desc{};Desc.ByteWidth=static_cast<UINT>(Bytes);
Desc.Usage=D3D11_USAGE_DEFAULT;Desc.BindFlags=Bind;
D3D11_SUBRESOURCE_DATA Initial{};Initial.pSysMem=Data;
return SUCCEEDED(Device->CreateBuffer(&Desc,&Initial,Out));
}
static void AppendPngU32(std::vector<uint8>& Out,uint32 Value)
{
Out.push_back(static_cast<uint8>(Value >> 24));
Out.push_back(static_cast<uint8>(Value >> 16));
Out.push_back(static_cast<uint8>(Value >> 8));
Out.push_back(static_cast<uint8>(Value));
}
static uint32 PngCrc32(const uint8* Data,size_t Count)
{
uint32 Crc=0xffffffffu;
for(size_t I=0;I<Count;++I)
{
Crc^=Data[I];
for(int32 Bit=0;Bit<8;++Bit)Crc=(Crc>>1)^((Crc&1)?0xedb88320u:0u);
}
return Crc^0xffffffffu;
}
static void AppendPngChunk(std::vector<uint8>& Png,const char Type[4],const std::vector<uint8>& Data)
{
AppendPngU32(Png,static_cast<uint32>(Data.size()));
const size_t CrcStart=Png.size();
Png.insert(Png.end(),Type,Type+4);
Png.insert(Png.end(),Data.begin(),Data.end());
AppendPngU32(Png,PngCrc32(Png.data()+CrcStart,Png.size()-CrcStart));
}
bool SaveBackBufferPng(const std::string& Path)
{
ID3D11Texture2D* BackBuffer=nullptr;
if(FAILED(SwapChain->GetBuffer(0,IID_PPV_ARGS(&BackBuffer))))return false;
D3D11_TEXTURE2D_DESC Desc{};BackBuffer->GetDesc(&Desc);
Desc.Usage=D3D11_USAGE_STAGING;Desc.BindFlags=0;Desc.CPUAccessFlags=D3D11_CPU_ACCESS_READ;Desc.MiscFlags=0;
ID3D11Texture2D* Staging=nullptr;
const HRESULT CreateResult=Device->CreateTexture2D(&Desc,nullptr,&Staging);
if(FAILED(CreateResult)){BackBuffer->Release();return false;}
Context->CopyResource(Staging,BackBuffer);BackBuffer->Release();
D3D11_MAPPED_SUBRESOURCE Mapped{};
if(FAILED(Context->Map(Staging,0,D3D11_MAP_READ,0,&Mapped))){Staging->Release();return false;}
const size_t RowBytes=static_cast<size_t>(Desc.Width)*4;
std::vector<uint8> Raw((RowBytes+1)*Desc.Height);
for(UINT Y=0;Y<Desc.Height;++Y)
{
uint8* Row=Raw.data()+static_cast<size_t>(Y)*(RowBytes+1);
Row[0]=0;
std::memcpy(Row+1,static_cast<const uint8*>(Mapped.pData)+static_cast<size_t>(Y)*Mapped.RowPitch,RowBytes);
}
Context->Unmap(Staging,0);Staging->Release();
std::vector<uint8> Zlib{0x78,0x01};
uint32 AdlerA=1,AdlerB=0;
for(const uint8 Byte:Raw){AdlerA=(AdlerA+Byte)%65521u;AdlerB=(AdlerB+AdlerA)%65521u;}
for(size_t Offset=0;Offset<Raw.size();)
{
const uint16 Block=static_cast<uint16>(std::min<size_t>(65535,Raw.size()-Offset));
const bool bFinal=Offset+Block==Raw.size();
Zlib.push_back(bFinal?1:0);
Zlib.push_back(static_cast<uint8>(Block));Zlib.push_back(static_cast<uint8>(Block>>8));
const uint16 NotBlock=static_cast<uint16>(~Block);
Zlib.push_back(static_cast<uint8>(NotBlock));Zlib.push_back(static_cast<uint8>(NotBlock>>8));
Zlib.insert(Zlib.end(),Raw.begin()+Offset,Raw.begin()+Offset+Block);
Offset+=Block;
}
AppendPngU32(Zlib,(AdlerB<<16)|AdlerA);
std::vector<uint8> Png{137,80,78,71,13,10,26,10};
std::vector<uint8> Ihdr;AppendPngU32(Ihdr,Desc.Width);AppendPngU32(Ihdr,Desc.Height);
Ihdr.insert(Ihdr.end(),{8,6,0,0,0});AppendPngChunk(Png,"IHDR",Ihdr);
AppendPngChunk(Png,"IDAT",Zlib);AppendPngChunk(Png,"IEND",{});
std::ofstream File(Path,std::ios::binary);
if(!File)return false;
File.write(reinterpret_cast<const char*>(Png.data()),static_cast<std::streamsize>(Png.size()));
return File.good();
}
bool Resize(UINT NewWidth,UINT NewHeight)
{
if(!Device||NewWidth==0||NewHeight==0)return false;
Width=static_cast<int32>(NewWidth);Height=static_cast<int32>(NewHeight);
if(RenderTarget){RenderTarget->Release();RenderTarget=nullptr;}
if(DepthView){DepthView->Release();DepthView=nullptr;}
if(SwapChain->ResizeBuffers(0,NewWidth,NewHeight,DXGI_FORMAT_UNKNOWN,0)!=S_OK)return false;
ID3D11Texture2D* Back=nullptr;
if(FAILED(SwapChain->GetBuffer(0,IID_PPV_ARGS(&Back))))return false;
const HRESULT RtvResult=Device->CreateRenderTargetView(Back,nullptr,&RenderTarget);Back->Release();
if(FAILED(RtvResult))return false;
D3D11_TEXTURE2D_DESC DepthDesc{};DepthDesc.Width=NewWidth;DepthDesc.Height=NewHeight;
DepthDesc.MipLevels=1;DepthDesc.ArraySize=1;DepthDesc.Format=DXGI_FORMAT_D24_UNORM_S8_UINT;
DepthDesc.SampleDesc.Count=1;DepthDesc.Usage=D3D11_USAGE_DEFAULT;DepthDesc.BindFlags=D3D11_BIND_DEPTH_STENCIL;
ID3D11Texture2D* Depth=nullptr;
if(FAILED(Device->CreateTexture2D(&DepthDesc,nullptr,&Depth)))return false;
const HRESULT DsvResult=Device->CreateDepthStencilView(Depth,nullptr,&DepthView);Depth->Release();
return SUCCEEDED(DsvResult);
}
bool InitializeDevice()
{
DXGI_SWAP_CHAIN_DESC Desc{};Desc.BufferCount=1;Desc.BufferDesc.Format=DXGI_FORMAT_R8G8B8A8_UNORM;
Desc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;Desc.OutputWindow=Window;Desc.SampleDesc.Count=1;
Desc.Windowed=TRUE;Desc.SwapEffect=DXGI_SWAP_EFFECT_DISCARD;
D3D_FEATURE_LEVEL Feature{};
if(FAILED(D3D11CreateDeviceAndSwapChain(nullptr,D3D_DRIVER_TYPE_HARDWARE,nullptr,0,nullptr,0,
D3D11_SDK_VERSION,&Desc,&SwapChain,&Device,&Feature,&Context)))return false;
const char* ShaderSource=R"(
cbuffer C:register(b0){float4x4 VP;float3 Camera;float FogStart;float3 Forward;float FogEnd;float3 LightDir;float Ambient;float4 Pad;}
struct I{float3 p:POSITION;float3 n:NORMAL;};
struct O{float4 p:SV_POSITION;float3 world:TEXCOORD0;float3 n:NORMAL;};
O VS(I i){O o;float3 p=i.p*Pad.x;o.p=mul(float4(p,1),VP);o.world=p;o.n=normalize(i.n);return o;}
float4 PS(O i):SV_TARGET{
float3 N=normalize(i.n);float3 V=normalize(Camera-i.world);float3 L=normalize(-LightDir);
float Diffuse=saturate(dot(N,L));float Head=saturate(dot(N,V));
float Dist=length(Camera-i.world);float Atten=1.0-saturate(Dist/95.0);
float3 Rock=lerp(float3(0.30,0.22,0.16),float3(0.48,0.43,0.34),saturate(N.z*0.5+0.5));
// Keep the camera fill broad and low-amplitude. The old squared, high-intensity
// lobe made the 25 cm density-lattice normal variation read as horizontal bands.
Head=Head*Atten;
float3 Lit=Rock*(Ambient+0.88*Diffuse)+float3(0.50,0.69,0.82)*Head*0.75;
float Fog=saturate((Dist-FogStart)/(FogEnd-FogStart));
Lit=lerp(Lit,float3(0.10,0.14,0.19),Fog);return float4(Lit,1);
})";
ID3DBlob* VsCode=nullptr;ID3DBlob* PsCode=nullptr;ID3DBlob* Errors=nullptr;
HRESULT Hr=D3DCompile(ShaderSource,std::strlen(ShaderSource),nullptr,nullptr,nullptr,"VS","vs_5_0",0,0,&VsCode,&Errors);
if(FAILED(Hr)){if(Errors)std::fprintf(stderr,"Vertex shader compile: %s\n",static_cast<const char*>(Errors->GetBufferPointer()));if(Errors)Errors->Release();return false;}
Hr=D3DCompile(ShaderSource,std::strlen(ShaderSource),nullptr,nullptr,nullptr,"PS","ps_5_0",0,0,&PsCode,&Errors);
if(FAILED(Hr)){if(Errors)std::fprintf(stderr,"Pixel shader compile: %s\n",static_cast<const char*>(Errors->GetBufferPointer()));if(Errors)Errors->Release();VsCode->Release();return false;}
Hr=Device->CreateVertexShader(VsCode->GetBufferPointer(),VsCode->GetBufferSize(),nullptr,&VertexShader);
if(SUCCEEDED(Hr))Hr=Device->CreatePixelShader(PsCode->GetBufferPointer(),PsCode->GetBufferSize(),nullptr,&PixelShader);
D3D11_INPUT_ELEMENT_DESC Elements[]={{"POSITION",0,DXGI_FORMAT_R32G32B32_FLOAT,0,0,D3D11_INPUT_PER_VERTEX_DATA,0},
{"NORMAL",0,DXGI_FORMAT_R32G32B32_FLOAT,0,12,D3D11_INPUT_PER_VERTEX_DATA,0}};
if(SUCCEEDED(Hr))Hr=Device->CreateInputLayout(Elements,2,VsCode->GetBufferPointer(),VsCode->GetBufferSize(),&InputLayout);
VsCode->Release();PsCode->Release();if(FAILED(Hr))return false;
D3D11_BUFFER_DESC ConstantDesc{};ConstantDesc.ByteWidth=sizeof(FConstants);ConstantDesc.Usage=D3D11_USAGE_DEFAULT;
ConstantDesc.BindFlags=D3D11_BIND_CONSTANT_BUFFER;
if(FAILED(Device->CreateBuffer(&ConstantDesc,nullptr,&Constants)))return false;
D3D11_RASTERIZER_DESC Raster{};Raster.FillMode=D3D11_FILL_SOLID;Raster.CullMode=D3D11_CULL_NONE;
Raster.DepthClipEnable=TRUE;if(FAILED(Device->CreateRasterizerState(&Raster,&SolidRasterizer)))return false;
Raster.FillMode=D3D11_FILL_WIREFRAME;if(FAILED(Device->CreateRasterizerState(&Raster,&WireRasterizer)))return false;
return Resize(Width,Height);
}
size_t PrintParity()
{
if(bParityChecked||!World)return 0;
bParityChecked=true;size_t MismatchCount=0;
std::map<std::string,size_t> Kinds;
for(size_t I=0;I<World->DensitySamples.size();++I)
{
const FStandaloneParitySample& S=World->DensitySamples[I];
const float Actual=World->Generator->GetDensityAt(static_cast<float>(S.PositionVoxels.X),
static_cast<float>(S.PositionVoxels.Y),static_cast<float>(S.PositionVoxels.Z));
++Kinds[S.Kind];
if(std::bit_cast<uint32>(Actual)!=std::bit_cast<uint32>(S.PluginDensity))
{
++MismatchCount;
std::fprintf(stderr,"PARITY MISMATCH %s strate=%d voxels=(%.6f,%.6f,%.6f) plugin=%.9g standalone=%.9g\n",
S.Kind.c_str(),S.StrateIndex,S.PositionVoxels.X,S.PositionVoxels.Y,S.PositionVoxels.Z,S.PluginDensity,Actual);
}
}
std::printf("Density parity: %zu/%zu bit-identical; mismatches=%zu\n",
World->DensitySamples.size()-MismatchCount,World->DensitySamples.size(),MismatchCount);
for(const auto& [Kind,Count]:Kinds)std::printf(" %-24s %zu\n",Kind.c_str(),Count);
std::fflush(stdout);
std::fflush(stdout);
return MismatchCount;
}
bool ConfigureWorld(std::string& Error)
{
ShapeWorld.reset();
Snapshot={};
World=std::make_shared<FStandaloneOwnerWorld>();
if(!StandaloneOwnerLoader::Resolve(OwnerJsonRoot,*World,Error))return false;
if(!bParityChecked&&Seed==World->Seed&&!bRoundTunnels)PrintParity();
const int32 ExportClipRadius=World->ClipRadius;
World->ClipRadius=ClipRadius;
World->Settings->ClipRadius=ClipRadius;
if(!bPrintedClipOverride)
{
bPrintedClipOverride=true;
const double FullDetailWidth=static_cast<double>(2*ClipRadius+2)
*CHUNK_SIZE*VOXEL_SIZE/100.0;
std::printf("Standalone clip override: exported radius=%d (112 m cube) -> radius=%d (%.0f m LOD0 cube), voxel size=25 cm.\n",
ExportClipRadius,ClipRadius,FullDetailWidth);
}
if(!PrepareStandaloneDensityWorld(*World,Seed,bRoundTunnels,
bRoundTunnelEnhanced,Error))return false;
if(MaxClipLevelOverride>=0)
{
World->MaxClipLevel=MaxClipLevelOverride;
World->Settings->MaxClipLevel=MaxClipLevelOverride;
std::printf("Standalone max clip level override applied after world reload: max_level=%d.\n",
MaxClipLevelOverride);
}
// Compile one world field before streaming. The streamer already prioritizes the
// player's neighborhood, so a second near-only field would only duplicate work.
if(bShapeWorld&&!BuildShapeWorldForCamera(Error,true,false))return false;
LoadMeshCache();
return true;
}
bool BuildShapeWorldForCamera(std::string& Error,bool bIncludeFarWorld=false,
bool bNeighborhoodOnly=false)
{
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
const FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(*World,CameraVoxels);
FIntVector Min(INT32_MAX,INT32_MAX,INT32_MAX),Max(INT32_MIN,INT32_MIN,INT32_MIN);
FIntVector ClipMin(INT32_MAX,INT32_MAX,INT32_MAX),ClipMax(INT32_MIN,INT32_MIN,INT32_MIN);
uint64 FineTiles=0;
InitialNeighborhoodTiles.clear();
const FIntVector CenterChunk=Desired.CenterChunk;
for(const FVoxelTileKey& Tile:Desired.Tiles)
{
const FIntVector Origin=Tile.OriginVoxels();
const int32 Extent=Tile.ExtentVoxels();
ClipMin.X=std::min(ClipMin.X,Origin.X);ClipMin.Y=std::min(ClipMin.Y,Origin.Y);ClipMin.Z=std::min(ClipMin.Z,Origin.Z);
ClipMax.X=std::max(ClipMax.X,Origin.X+Extent);ClipMax.Y=std::max(ClipMax.Y,Origin.Y+Extent);ClipMax.Z=std::max(ClipMax.Z,Origin.Z+Extent);
if(bNeighborhoodOnly)
{
if(Tile.Level!=0||std::abs(Tile.Coord.X-CenterChunk.X)>1
||std::abs(Tile.Coord.Y-CenterChunk.Y)>1
||std::abs(Tile.Coord.Z-CenterChunk.Z)>1)continue;
InitialNeighborhoodTiles.push_back(Tile);
}
else if(Tile.Level>=World->FullResClipLevels)continue;
Min.X=std::min(Min.X,Origin.X);Min.Y=std::min(Min.Y,Origin.Y);Min.Z=std::min(Min.Z,Origin.Z);
Max.X=std::max(Max.X,Origin.X+Extent);Max.Y=std::max(Max.Y,Origin.Y+Extent);Max.Z=std::max(Max.Z,Origin.Z+Extent);
++FineTiles;
}
if(!FineTiles){Error="no full-detail tiles are available for shape compilation";return false;}
if(bNeighborhoodOnly)
{
if(InitialNeighborhoodTiles.size()!=27)
{Error="the 3x3x3 player neighborhood does not contain 27 LOD0 tiles";return false;}
constexpr int32 NearBuildPad=64;
Min.X-=NearBuildPad;Min.Y-=NearBuildPad;Min.Z-=NearBuildPad;
Max.X+=NearBuildPad;Max.Y+=NearBuildPad;Max.Z+=NearBuildPad;
}
Snapshot=VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(OwnerJsonRoot,Seed,ClipRadius,
MaxClipLevelOverride,bRoundTunnels,bRoundTunnelEnhanced,Error);
if(!Snapshot)
{if(Error.empty())Error="the standalone adapter could not make a resolved core snapshot";return false;}
ShapeWorld=std::make_unique<VoxelForgeCore::World>(Snapshot);
const int32 ShapeWorkers=bNeighborhoodOnly?(WorkerCount>=8?2:1):WorkerCount;
VoxelForgeCore::ShapeBuildRequest Request;
Request.minVoxel={Min.X,Min.Y,Min.Z};Request.maxVoxel={Max.X,Max.Y,Max.Z};
Request.clipMinVoxel={ClipMin.X,ClipMin.Y,ClipMin.Z};
Request.clipMaxVoxel={ClipMax.X,ClipMax.Y,ClipMax.Z};
Request.workerLimit=static_cast<uint32>(ShapeWorkers);Request.detail=ShapeDetailVariant;
Request.includeFarWorld=bIncludeFarWorld;Request.roundTunnels=bRoundTunnels;
Request.enhancedTunnelWalls=bRoundTunnelEnhanced;
Request.profileDetailBand=bProfileDetailBand;
const auto ShapeCompileStart=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=shape_compile begin_ms=%.3f\n",
std::chrono::duration<double,std::milli>(ShapeCompileStart-ColdProcessStart).count());
if(!ShapeWorld->compile(Request,CoreScheduler,Error))
{ShapeWorld.reset();return false;}
const auto ShapeCompileEnd=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=shape_compile end_ms=%.3f duration_ms=%.3f\n",
std::chrono::duration<double,std::milli>(ShapeCompileEnd-ColdProcessStart).count(),
std::chrono::duration<double,std::milli>(ShapeCompileEnd-ShapeCompileStart).count());
bShapePipelineActive=bNeighborhoodOnly;
bNeighborhoodReadyReported=false;
bFarShapeStagePending=bShapeWorld&&!bNeighborhoodOnly&&!ShapeWorld->hasFarWorld();
std::printf("[ShapeRegion] fine_tiles=%llu bounds=(%d,%d,%d)..(%d,%d,%d) clip=(%d,%d,%d)..(%d,%d,%d)\n",
static_cast<unsigned long long>(FineTiles),Min.X,Min.Y,Min.Z,Max.X,Max.Y,Max.Z,
ClipMin.X,ClipMin.Y,ClipMin.Z,ClipMax.X,ClipMax.Y,ClipMax.Z);
return true;
}
bool StartFullShapeBuild(const std::vector<FVoxelTileKey>& FullDesired,std::string& Error)
{
FIntVector FineMin(INT32_MAX,INT32_MAX,INT32_MAX),FineMax(INT32_MIN,INT32_MIN,INT32_MIN);
FIntVector ClipMin(INT32_MAX,INT32_MAX,INT32_MAX),ClipMax(INT32_MIN,INT32_MIN,INT32_MIN);
for(const FVoxelTileKey& Tile:FullDesired)
{
const FIntVector Origin=Tile.OriginVoxels();const int32 Extent=Tile.ExtentVoxels();
ClipMin.X=std::min(ClipMin.X,Origin.X);ClipMin.Y=std::min(ClipMin.Y,Origin.Y);ClipMin.Z=std::min(ClipMin.Z,Origin.Z);
ClipMax.X=std::max(ClipMax.X,Origin.X+Extent);ClipMax.Y=std::max(ClipMax.Y,Origin.Y+Extent);ClipMax.Z=std::max(ClipMax.Z,Origin.Z+Extent);
if(Tile.Level>=World->FullResClipLevels)continue;
FineMin.X=std::min(FineMin.X,Origin.X);FineMin.Y=std::min(FineMin.Y,Origin.Y);FineMin.Z=std::min(FineMin.Z,Origin.Z);
FineMax.X=std::max(FineMax.X,Origin.X+Extent);FineMax.Y=std::max(FineMax.Y,Origin.Y+Extent);FineMax.Z=std::max(FineMax.Z,Origin.Z+Extent);
}
if(FineMin.X==INT32_MAX||ClipMin.X==INT32_MAX)
{Error="the full shape build has no desired detail or clipmap tiles";return false;}
PendingFullShapeWorld=std::make_unique<VoxelForgeCore::World>(Snapshot);
FullShapeBuildError.clear();bFullShapeBuildSucceeded=false;
bFullShapeBuildFinished.store(false,std::memory_order_relaxed);
const int32 FullWorkers=WorkerCount>=8?6:WorkerCount;
FullShapeBuildStart=std::chrono::steady_clock::now();
FullShapeBuildThread=std::thread([this,FineMin,FineMax,ClipMin,ClipMax,FullWorkers]()
{
VoxelForgeCore::ShapeBuildRequest Request;
Request.minVoxel={FineMin.X,FineMin.Y,FineMin.Z};
Request.maxVoxel={FineMax.X,FineMax.Y,FineMax.Z};
Request.clipMinVoxel={ClipMin.X,ClipMin.Y,ClipMin.Z};
Request.clipMaxVoxel={ClipMax.X,ClipMax.Y,ClipMax.Z};
Request.workerLimit=static_cast<uint32>(FullWorkers);Request.detail=ShapeDetailVariant;
Request.includeFarWorld=true;Request.roundTunnels=bRoundTunnels;
Request.enhancedTunnelWalls=bRoundTunnelEnhanced;
Request.profileDetailBand=bProfileDetailBand;
bFullShapeBuildSucceeded=PendingFullShapeWorld->compile(
Request,CoreScheduler,FullShapeBuildError);
bFullShapeBuildFinished.store(true,std::memory_order_release);
});
std::printf("[ShapePipelineBuildStart] neighborhood_tiles=%zu near_mesh_workers=%d full_shape_workers=%d\n",
InitialNeighborhoodTiles.size(),WorkerCount>=8?2:1,FullWorkers);
std::fflush(stdout);
return true;
}
FStandaloneMeshCacheMetadata MakeMeshCacheMetadata()const
{
FStandaloneMeshCacheMetadata Metadata;
Metadata.SourceDataHash=HashStandaloneFile(DataPath);
Metadata.Seed=Seed;Metadata.ClipRadius=ClipRadius;
Metadata.FullResClipLevels=World->FullResClipLevels;
Metadata.CoarseTileCells=World->CoarseTileCells;
Metadata.StrateContentCutMinLevel=World->StrateContentCutMinLevel;
Metadata.SkirtCells=World->SkirtCells;
Metadata.LODOctaveDrop=World->LODOctaveDrop;
Metadata.bGenerateSkirts=World->bGenerateSkirts?1:0;
Metadata.AlgorithmVersion=FStandaloneMeshCache::CurrentVersion;
Metadata.TunnelMode=bRoundTunnels?(bRoundTunnelEnhanced?2u:1u):0u;
return Metadata;
}
void LoadMeshCache()
{
MeshCache.Clear();
if(bForceGenerate||bShapeWorld||!World)return;
const char* ModeSuffix=!bRoundTunnels?"_base":
(bRoundTunnelEnhanced?"_round_detailed":"_round_legacy");
const std::filesystem::path CachePath=std::filesystem::path(DataPath).parent_path()
/(std::string("VoxelForge_seed")+std::to_string(Seed)+"_r"
+std::to_string(ClipRadius)+ModeSuffix+".vfmesh");
MeshCachePath=CachePath.string();
const auto Begin=std::chrono::steady_clock::now();
std::string CacheError;
if(MeshCache.Load(MeshCachePath,MakeMeshCacheMetadata(),CacheError))
{
const double Seconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-Begin).count();
std::printf("[MeshCache] loaded %zu tiles, %.2f MiB in %.3f s from %s\n",
MeshCache.Num(),static_cast<double>(MeshCache.GetBytesLoaded())/1048576.0,
Seconds,MeshCachePath.c_str());
std::fflush(stdout);
}
else if(CacheError!="cache file is missing or unreadable")
std::printf("[MeshCache] ignored %s: %s\n",MeshCachePath.c_str(),CacheError.c_str());
}
void StartGeneration()
{
StopGeneration();
ReleaseMeshes();
GenerationStart=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=generation_setup begin_ms=%.3f\n",
std::chrono::duration<double,std::milli>(GenerationStart-ColdProcessStart).count());
std::string Error;
if(!ConfigureWorld(Error))
{std::fprintf(stderr,"World load failed: %s\n",Error.c_str());MessageBoxA(Window,Error.c_str(),"VoxelForge viewer",MB_ICONERROR);return;}
std::printf("[ColdTimeline] stage=generation_setup configured_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count());
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
BuildTargetChunk=StandaloneWorldMesher::CameraChunk(CameraVoxels);
bFullDetailReported=false;bInitialClipmapReported=false;bAutoCaptureWritten=false;
if(bProfileAttribution)
{
VoxelDensityProfile::SetMode(VoxelDensityProfile::EMode::Attribution,128);
VoxelDensityProfile::CalibrateTimer();
VoxelDensityProfile::Reset();
std::printf("Density stage profiling enabled (Attribution, sample interval 128).\n");
}
const FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(*World,CameraVoxels);
DesiredTiles=Desired.Tiles;
if(ShapeWorld)
{
const auto CoreTiles=ShapeWorld->desiredTiles({CameraVoxels.X,CameraVoxels.Y,CameraVoxels.Z});
DesiredTiles.clear();DesiredTiles.reserve(CoreTiles.size());
for(const auto& Key:CoreTiles)
DesiredTiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
}
if(CaptureTileLimit>0&&CapturePath.size())
{
const size_t Before=DesiredTiles.size();
const V3 F=Forward(),R=Normalize(Cross(F,{0,0,1})),U=Normalize(Cross(R,F));
const double TanHalfFov=std::tan(1.04719755*0.5);
const double Aspect=static_cast<double>(Width)/std::max(1,Height);
struct FCaptureTileRank { FVoxelTileKey Tile; double Depth=0.0; };
std::vector<FCaptureTileRank> Visible;Visible.reserve(DesiredTiles.size());
for(const FVoxelTileKey& Tile:DesiredTiles)
{
const FIntVector Origin=Tile.OriginVoxels();
const double HalfExtent=Tile.ExtentVoxels()*0.8660254037844386;
const double DX=Origin.X+Tile.ExtentVoxels()*0.5-CameraVoxels.X;
const double DY=Origin.Y+Tile.ExtentVoxels()*0.5-CameraVoxels.Y;
const double DZ=Origin.Z+Tile.ExtentVoxels()*0.5-CameraVoxels.Z;
const double Depth=DX*F.X+DY*F.Y+DZ*F.Z;
if(Depth+HalfExtent<0.0)continue;
const double LateralX=std::abs(DX*R.X+DY*R.Y+DZ*R.Z);
const double LateralY=std::abs(DX*U.X+DY*U.Y+DZ*U.Z);
const double ForwardReach=std::max(1.0,Depth+HalfExtent);
if(LateralX>ForwardReach*TanHalfFov*Aspect+HalfExtent
||LateralY>ForwardReach*TanHalfFov+HalfExtent)continue;
Visible.push_back({Tile,std::max(0.0,Depth)});
}
std::stable_sort(Visible.begin(),Visible.end(),[](const auto& A,const auto& B)
{return A.Depth<B.Depth;});
if(Visible.size()>static_cast<size_t>(CaptureTileLimit))
Visible.resize(static_cast<size_t>(CaptureTileLimit));
DesiredTiles.clear();DesiredTiles.reserve(Visible.size());
for(const FCaptureTileRank& Ranked:Visible)DesiredTiles.push_back(Ranked.Tile);
std::printf("[CaptureTileLimit] frustum_tiles=%zu selected=%zu original_desired=%zu limit=%d; reference capture only\n",
Visible.size(),DesiredTiles.size(),Before,CaptureTileLimit);
}
DesiredTileSet.clear();DesiredTileSet.reserve(DesiredTiles.size()*2+1);
for(const FVoxelTileKey& Key:DesiredTiles)DesiredTileSet.insert(Key);
for(int32 I=0;I<=MaxLevels;++I)DesiredByLevel[I]=0;
for(const FVoxelTileKey& Tile:DesiredTiles)++DesiredByLevel[Tile.Level];
const int32 StreamWorkers=bShapePipelineActive?(WorkerCount>=8?2:1):WorkerCount;
Streamer=std::make_unique<FStandaloneStreamingGenerator>(*World,StreamWorkers,false,
(!bShapeWorld&&MeshCache.IsLoaded())?&MeshCache:nullptr,
bFarShapeStagePending?World->FullResClipLevels-1:-1,
false,false,false,false,ShapeWorld.get());
if(bGpuFarEnabled&&ShapeWorld&&ShapeWorld->hasFarWorld())
{
ScheduleGpuFarTiles(DesiredTiles);
if(bGpuFarAuditEnabled)
{
std::vector<FVoxelTileKey> AuditKeys;AuditKeys.reserve(GpuFarEligibleTiles.size());
for(const FVoxelTileKey& Key:DesiredTiles)
if(Key.Level>=6&&GpuFarEligibleTiles.contains(Key))AuditKeys.push_back(Key);
GpuFarAudit=std::make_unique<FFarSurvivalAudit>(*World,*ShapeWorld,AuditKeys,false);
}
}
if(bShapePipelineActive)Streamer->SetDesiredTileFilter(InitialNeighborhoodTiles);
else if(CaptureTileLimit>0&&CapturePath.size())
Streamer->SetDesiredTileFilter(DesiredTiles);
const FStandaloneStreamingUpdate Update=Streamer->Start(CameraVoxels,{},CrossingIndex);
if(bShapePipelineActive&&Update.DesiredTiles!=static_cast<int32>(InitialNeighborhoodTiles.size()))
{
StopGeneration();
Error="the initial neighborhood streamer did not accept all 27 tiles";
std::fprintf(stderr,"World load failed: %s\n",Error.c_str());
return;
}
FCrossingWork& InitialWork=CrossingWork[CrossingIndex];
InitialWork.SubmittedJobs=Update.NewJobs;InitialWork.PendingJobs=Update.NewJobs;
InitialWork.StartTime=GenerationStart;
bGenerationRunning=true;bRebuildPending=false;
std::printf("[ColdTimeline] stage=cpu_stream_start submitted_ms=%.3f cpu_jobs=%d gpu_queued=%zu\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count(),
Update.NewJobs,GpuFarQueue.size());
const char* TunnelMode=!bRoundTunnels?"":(bRoundTunnelEnhanced
?" with detailed round/winding tunnels":" with legacy round/winding tunnels");
std::printf("Streaming seed %d%s%s: %d desired tiles, %d full-detail tiles, %d workers; upload budget %d batches / %.1f ms per frame.\n",
Seed,TunnelMode,bShapeWorld?" [shape intervals]":"",Update.DesiredTiles,
Update.FullResTiles,Streamer->GetWorkerCount(),MaxBatchUploadsPerFrame,BatchUploadBudgetMilliseconds);
if(bShapePipelineActive)
{
std::string ShapeError;
if(!StartFullShapeBuild(DesiredTiles,ShapeError))
{
StopGeneration();
std::fprintf(stderr,"World load failed: %s\n",ShapeError.c_str());
return;
}
}
std::fflush(stdout);
}
void RequestSeed(int32 Delta)
{
const uint32 Next=static_cast<uint32>(Seed)+static_cast<uint32>(Delta);
Seed=static_cast<int32>(Next);bRebuildPending=true;
std::printf("Seed changed to %d; replacing the current streaming world.\n",Seed);
}
void StartFarShapeGeneration()
{
if(!bFarShapeStagePending||!ShapeWorld||ShapeWorld->hasFarWorld()||!Streamer)return;
ShapeWorld->buildFarWorld();
bFarShapeStagePending=false;
Streamer->Stop();
std::vector<FVoxelTileKey> ResidentKeys;ResidentKeys.reserve(ResidentTiles.size());
for(const auto& Pair:ResidentTiles)ResidentKeys.push_back(Pair.first);
Streamer.reset();
Streamer=std::make_unique<FStandaloneStreamingGenerator>(*World,WorkerCount,false,nullptr,-1,
false,false,false,false,ShapeWorld.get());
if(bGpuFarEnabled)
{
ScheduleGpuFarTiles(DesiredTiles);
if(bGpuFarAuditEnabled&&World)
{
std::vector<FVoxelTileKey> AuditKeys;AuditKeys.reserve(GpuFarEligibleTiles.size());
for(const FVoxelTileKey& Key:DesiredTiles)
if(Key.Level>=6&&GpuFarEligibleTiles.contains(Key))AuditKeys.push_back(Key);
GpuFarAudit=std::make_unique<FFarSurvivalAudit>(*World,*ShapeWorld,AuditKeys,false);
}
}
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
++CrossingIndex;
const FStandaloneStreamingUpdate Update=Streamer->Start(CameraVoxels,ResidentKeys,CrossingIndex);
FCrossingWork& Work=CrossingWork[CrossingIndex];
Work.SubmittedJobs=Update.NewJobs;Work.PendingJobs=Update.NewJobs;
Work.StartTime=std::chrono::steady_clock::now();
bGenerationRunning=true;
std::printf("[FarStreamStart] desired=%d retained=%d new_jobs=%d workers=%d\n",
Update.DesiredTiles,Update.RetainedResidentTiles,Update.NewJobs,WorkerCount);
std::fflush(stdout);
}
void RecordGpuCrossingTileReady(const FVoxelTileKey& Key)
{
const auto ReadyAt=std::chrono::steady_clock::now();
for(auto& Pair:CrossingWork)
{
FCrossingWork& Work=Pair.second;
if(Work.bHasNearestNewTile&&Work.NearestNewTile==Key
&&Work.NearestReadySeconds<0.0&&Work.StartTime.time_since_epoch().count()!=0)
Work.NearestReadySeconds=std::chrono::duration<double>(ReadyAt-Work.StartTime).count();
}
}
bool IsRenderedTileReady(const FVoxelTileKey& Key)
{
if(bGpuFarEnabled&&ShapeWorld&&ShapeWorld->hasFarWorld()
&&GpuFarEligibleTiles.contains(Key))
{
auto It=GpuFarTiles.find(Key);
if(It==GpuFarTiles.end())return false;
FGpuFarTile& Tile=It->second;
if(Tile.BatchIndex!=UINT32_MAX&&Tile.BatchIndex<GpuFarBatches.size())
{
FGpuFarBatch& Batch=GpuFarBatches[Tile.BatchIndex];
if(!Batch.bGpuComplete&&Batch.CompletionEvent&&Context
&&Context->GetData(Batch.CompletionEvent,nullptr,0,D3D11_ASYNC_GETDATA_DONOTFLUSH)==S_OK)
{
Batch.bGpuComplete=true;
const auto PollAt=std::chrono::steady_clock::now();
const double PollMs=std::chrono::duration<double,std::milli>(PollAt-ColdProcessStart).count();
if(GpuFarFirstCompletionPollMs<0.0)GpuFarFirstCompletionPollMs=PollMs;
GpuFarLastCompletionPollMs=PollMs;++GpuFarCompletionPolls;
Batch.CompletionEvent->Release();Batch.CompletionEvent=nullptr;
}
if(Batch.bGpuComplete&&!Batch.bTimingResolved)
{
if(VoxelForgeGpuFarViewer::ResolveGpuTiming(Context,Batch.TimingQueries,
Batch.GpuDispatchMs,&Batch.TimestampFrequency))
{
Batch.bTimingResolved=true;
GpuFarSubmissionSpanMs+=Batch.GpuDispatchMs;
GpuFarSubmissionSpanMaxMs=std::max(GpuFarSubmissionSpanMaxMs,Batch.GpuDispatchMs);
}
}
if(Batch.bGpuComplete&&Batch.bTimingResolved&&!Tile.bTimingResolved
&&Batch.TimestampFrequency)
{
double TileDispatchMs=0.0;
if(VoxelForgeGpuFarViewer::ResolveGpuTimestampPair(Context,Tile.TimingQueries,
Batch.TimestampFrequency,TileDispatchMs))
{
Tile.GpuDispatchMs=TileDispatchMs;Tile.bTimingResolved=true;
GpuFarGpuDispatchMs+=TileDispatchMs;
GpuFarGpuDispatchMaxMs=std::max(GpuFarGpuDispatchMaxMs,TileDispatchMs);
}
}
if(Batch.bGpuComplete)RecordGpuCrossingTileReady(Key);
return Batch.bGpuComplete;
}
if(!Tile.bGpuComplete&&Tile.CompletionEvent&&Context
&&Context->GetData(Tile.CompletionEvent,nullptr,0,D3D11_ASYNC_GETDATA_DONOTFLUSH)==S_OK)
{
Tile.bGpuComplete=true;
Tile.CompletionEvent->Release();Tile.CompletionEvent=nullptr;
}
if(Tile.bGpuComplete&&!Tile.bTimingResolved)
{
double AsyncDispatchMs=0.0;
if(VoxelForgeGpuFarViewer::ResolveGpuTiming(Context,Tile.TimingQueries,AsyncDispatchMs))
{
if(Tile.GpuDispatchMs==0.0)
{
Tile.GpuDispatchMs=AsyncDispatchMs;
GpuFarGpuDispatchMs+=AsyncDispatchMs;
GpuFarGpuDispatchMaxMs=std::max(GpuFarGpuDispatchMaxMs,AsyncDispatchMs);
}
Tile.bTimingResolved=true;
}
}
if(Tile.bGpuComplete)RecordGpuCrossingTileReady(Key);
return Tile.bGpuComplete;
}
return ResidentTiles.contains(Key);
}
void PrepareGpuFarInputs(std::vector<FVoxelTileKey> NeedPreparation)
{
if(NeedPreparation.empty())return;
const auto PrepareStart=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=gpu_input_export begin_ms=%.3f tiles=%zu\n",
std::chrono::duration<double,std::milli>(PrepareStart-ColdProcessStart).count(),NeedPreparation.size());
std::vector<std::optional<VoxelForgeCore::FarFieldTileInput>> Inputs(NeedPreparation.size());
std::vector<std::string> Errors(NeedPreparation.size());
const std::size_t ThreadCount=std::min<std::size_t>(8,NeedPreparation.size());
std::atomic<std::size_t> Next{0};
std::vector<double> WorkerElapsed(ThreadCount,0.0);
std::vector<std::thread> Workers;Workers.reserve(ThreadCount);
for(std::size_t Worker=0;Worker<ThreadCount;++Worker)
{
Workers.emplace_back([&,Worker]
{
const auto WorkerStart=std::chrono::steady_clock::now();
for(;;)
{
const std::size_t Index=Next.fetch_add(1,std::memory_order_relaxed);
if(Index>=NeedPreparation.size())break;
const FVoxelTileKey& Key=NeedPreparation[Index];
const VoxelForgeCore::TileKey CoreKey{{Key.Coord.X,Key.Coord.Y,Key.Coord.Z},Key.Level};
try
{
Inputs[Index]=Key.Level<World->FullResClipLevels
?ShapeWorld->exportGpuFieldTile(CoreKey,Errors[Index])
:ShapeWorld->exportFarFieldTile(CoreKey,Errors[Index]);
}
catch(const std::exception& Error) { Errors[Index]=Error.what(); }
}
WorkerElapsed[Worker]=std::chrono::duration<double,std::milli>(
std::chrono::steady_clock::now()-WorkerStart).count();
});
}
for(std::thread& Worker:Workers)Worker.join();
const double PreparationMs=std::chrono::duration<double,std::milli>(
std::chrono::steady_clock::now()-PrepareStart).count();
double WorkerSumMs=0.0;for(const double Elapsed:WorkerElapsed)WorkerSumMs+=Elapsed;
GpuFarPreparationWallMs+=PreparationMs;GpuFarPreparationWorkerMs+=WorkerSumMs;
std::size_t Failed=0;
for(std::size_t Index=0;Index<NeedPreparation.size();++Index)
{
if(Inputs[Index])GpuFarPreparedInputs.emplace(NeedPreparation[Index],std::move(*Inputs[Index]));
else
{
++Failed;
GpuFarPreparationErrors.emplace(NeedPreparation[Index],Errors[Index].empty()
?"far-field input export failed":Errors[Index]);
}
}
std::printf("[GpuFarInputPrepare] tiles=%zu workers=%zu wall_ms=%.3f worker_sum_ms=%.3f failed=%zu\n",
NeedPreparation.size(),ThreadCount,PreparationMs,WorkerSumMs,Failed);
std::printf("[ColdTimeline] stage=gpu_input_export end_ms=%.3f duration_ms=%.3f worker_sum_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count(),
PreparationMs,WorkerSumMs);
std::fflush(stdout);
}
void ScheduleGpuFarTiles(const std::vector<FVoxelTileKey>& Keys)
{
GpuFarQueue.clear();GpuFarQueued.clear();GpuFarEligibleTiles.clear();
GpuFarPreparedInputs.clear();GpuFarPreparationErrors.clear();
if(!bGpuFarEnabled||!ShapeWorld||!ShapeWorld->hasFarWorld())return;
std::vector<FVoxelTileKey> CpuTiles;CpuTiles.reserve(Keys.size());
std::vector<FVoxelTileKey> Eligible;Eligible.reserve(Keys.size());
for(const FVoxelTileKey& Key:Keys)
{
const VoxelForgeCore::TileKey CoreKey{{Key.Coord.X,Key.Coord.Y,Key.Coord.Z},Key.Level};
const bool NearGpuEligible=Key.Level<World->FullResClipLevels;
if(NearGpuEligible||ShapeWorld->isFarFieldTileEligible(CoreKey))
{
Eligible.push_back(Key);
}
else CpuTiles.push_back(Key);
}
if(Eligible.size()>GpuFarOutputCapacitySlots)
{
for(auto& Pair:GpuFarTiles)ReleaseGpuFarTile(Pair.second);
GpuFarTiles.clear();GpuFarFreeOutputSlots.clear();GpuFarNextOutputSlot=0;
GpuFarOutputCapacitySlots=static_cast<uint32>(Eligible.size());
}
if(!Eligible.empty()&&GpuFarOutputCapacitySlots==0)
GpuFarOutputCapacitySlots=static_cast<uint32>(Eligible.size());
if(!Eligible.empty())
{
std::string PoolError;const auto ReserveStart=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=gpu_output_pool begin_ms=%.3f slots=%u\n",
std::chrono::duration<double,std::milli>(ReserveStart-ColdProcessStart).count(),
GpuFarOutputCapacitySlots);
if(!VoxelForgeGpuFarViewer::ReserveFarOutputPool(Device,Context,GpuFarShaderPath,
GpuFarOutputCapacitySlots,static_cast<uint32>(World->CoarseTileCells),PoolError))
{
std::fprintf(stderr,"[GpuFarPoolError] %s\n",PoolError.c_str());
bGpuFarEnabled=false;GpuFarOutputCapacitySlots=0;
CpuTiles=Keys;Eligible.clear();GpuFarTiles.clear();
}
GpuFarPoolReserveMs+=std::chrono::duration<double,std::milli>(
std::chrono::steady_clock::now()-ReserveStart).count();
std::printf("[ColdTimeline] stage=gpu_output_pool end_ms=%.3f duration_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count(),
GpuFarPoolReserveMs);
SampleGpuFarMemory();
}
std::vector<FVoxelTileKey> NeedPreparation;NeedPreparation.reserve(Eligible.size());
for(const FVoxelTileKey& Key:Eligible)
if(!GpuFarTiles.contains(Key))NeedPreparation.push_back(Key);
if(!NeedPreparation.empty())
PrepareGpuFarInputs(std::move(NeedPreparation));
std::vector<FVoxelTileKey> PreparedEligible;PreparedEligible.reserve(Eligible.size());
for(const FVoxelTileKey& Key:Eligible)
{
if(!GpuFarTiles.contains(Key)&&!GpuFarPreparedInputs.contains(Key))
{
CpuTiles.push_back(Key);
const auto Error=GpuFarPreparationErrors.find(Key);
std::fprintf(stderr,"[GpuFieldInputFallback] key=(%d,%d,%d,lod%d) reason=%s\n",
Key.Coord.X,Key.Coord.Y,Key.Coord.Z,Key.Level,
Error==GpuFarPreparationErrors.end()?"missing prepared input":Error->second.c_str());
continue;
}
GpuFarEligibleTiles.insert(Key);
if(!GpuFarTiles.contains(Key))
{GpuFarQueue.push_back(Key);GpuFarQueued.insert(Key);}
PreparedEligible.push_back(Key);
}
Eligible.swap(PreparedEligible);
std::sort(GpuFarQueue.begin(),GpuFarQueue.end(),[&](const FVoxelTileKey& A,const FVoxelTileKey& B)
{
if(A.Level!=B.Level)return A.Level<B.Level;
const FIntVector AO=A.OriginVoxels(),BO=B.OriginVoxels();
const double AC=(AO.X+0.5*A.ExtentVoxels()-Position.X*4.0)*(AO.X+0.5*A.ExtentVoxels()-Position.X*4.0)
+(AO.Y+0.5*A.ExtentVoxels()-Position.Y*4.0)*(AO.Y+0.5*A.ExtentVoxels()-Position.Y*4.0)
+(AO.Z+0.5*A.ExtentVoxels()-Position.Z*4.0)*(AO.Z+0.5*A.ExtentVoxels()-Position.Z*4.0);
const double BC=(BO.X+0.5*B.ExtentVoxels()-Position.X*4.0)*(BO.X+0.5*B.ExtentVoxels()-Position.X*4.0)
+(BO.Y+0.5*B.ExtentVoxels()-Position.Y*4.0)*(BO.Y+0.5*B.ExtentVoxels()-Position.Y*4.0)
+(BO.Z+0.5*B.ExtentVoxels()-Position.Z*4.0)*(BO.Z+0.5*B.ExtentVoxels()-Position.Z*4.0);
return AC<BC;
});
GpuFarQueued.clear();for(const FVoxelTileKey& Key:GpuFarQueue)GpuFarQueued.insert(Key);
if(Streamer)Streamer->SetDesiredTileFilter(CpuTiles);
const std::size_t NearGpuTiles=static_cast<std::size_t>(std::count_if(
GpuFarEligibleTiles.begin(),GpuFarEligibleTiles.end(),[&](const FVoxelTileKey& Key)
{return Key.Level<World->FullResClipLevels;}));
std::printf("[GpuFieldEligibility] eligible_gpu_tiles=%zu near_gpu_tiles=%zu cpu_fallback_tiles=%zu\n",
GpuFarEligibleTiles.size(),NearGpuTiles,Keys.size()-GpuFarEligibleTiles.size());
}
void PumpGpuFarGeneration()
{
if(!bGpuFarEnabled||!ShapeWorld||!ShapeWorld->hasFarWorld()||!Device||!Context
||GpuFarQueue.empty())return;
const auto PumpStart=std::chrono::steady_clock::now();
const double PumpMs=std::chrono::duration<double,std::milli>(PumpStart-ColdProcessStart).count();
if(GpuFarFirstPumpMs<0.0)GpuFarFirstPumpMs=PumpMs;
if(LastGpuFarPumpAt.time_since_epoch().count()!=0)
{
const double GapMs=std::chrono::duration<double,std::milli>(PumpStart-LastGpuFarPumpAt).count();
GpuFarPumpGapMs+=GapMs;GpuFarPumpGapMaxMs=std::max(GpuFarPumpGapMaxMs,GapMs);
}
LastGpuFarPumpAt=PumpStart;GpuFarLastPumpMs=PumpMs;++GpuFarPumpCalls;
const bool bDeferredBatch=!bGpuFarAuditEnabled;
if(bDeferredBatch)
{
std::string BatchError;
if(!VoxelForgeGpuFarViewer::BeginFarTileBatch(Device,Context,GpuFarShaderPath,BatchError))
{
std::fprintf(stderr,"[GpuFarBatchError] begin: %s\n",BatchError.c_str());
bGpuFarEnabled=false;return;
}
}
const auto Start=std::chrono::steady_clock::now();
int32 Built=0;
std::vector<FVoxelTileKey> BuiltKeys;BuiltKeys.reserve(32);
do
{
const FVoxelTileKey Key=GpuFarQueue.front();GpuFarQueue.pop_front();GpuFarQueued.erase(Key);
if(!DesiredTileSet.contains(Key)||GpuFarTiles.contains(Key))continue;
FGpuFarTile Tile;
if(!GpuFarFreeOutputSlots.empty())
{Tile.OutputSlot=GpuFarFreeOutputSlots.back();GpuFarFreeOutputSlots.pop_back();}
else if(GpuFarNextOutputSlot<GpuFarOutputCapacitySlots)
Tile.OutputSlot=GpuFarNextOutputSlot++;
else
{
std::fprintf(stderr,"[GpuFarPoolError] no free far-output slot for queued tile\n");
bGpuFarEnabled=false;break;
}
VoxelForgeGpuFarViewer::CpuMesh AuditMesh;
std::string Error;double EnqueueMs=0.0,GpuDispatchMs=0.0;
const VoxelForgeCore::TileKey CoreKey{{Key.Coord.X,Key.Coord.Y,Key.Coord.Z},Key.Level};
const auto PreparedInputIt=GpuFarPreparedInputs.find(Key);
const VoxelForgeCore::FarFieldTileInput* PreparedInput=PreparedInputIt==GpuFarPreparedInputs.end()
?nullptr:&PreparedInputIt->second;
if(!PreparedInput)
{
const auto PrepError=GpuFarPreparationErrors.find(Key);
std::fprintf(stderr,"[GpuFarInputError] key=(%d,%d,%d,lod%d): %s\n",
Key.Coord.X,Key.Coord.Y,Key.Coord.Z,Key.Level,
PrepError==GpuFarPreparationErrors.end()?"prepared far input is missing":PrepError->second.c_str());
GpuFarFreeOutputSlots.push_back(Tile.OutputSlot);
bGpuFarEnabled=false;
break;
}
if(!VoxelForgeGpuFarViewer::BuildFarTile(Device,Context,*ShapeWorld,CoreKey,
PreparedInput,
GpuFarShaderPath,&Tile.VertexBuffer,&Tile.IndexBuffer,&Tile.IndirectArgs,
&Tile.ConnectorVertexBuffer,&Tile.ConnectorIndexBuffer,
Tile.OutputSlot,GpuFarOutputCapacitySlots,&Tile.IndirectArgsByteOffset,
bDeferredBatch?nullptr:&Tile.CompletionEvent,
&Tile.TimingQueries,
(bGpuFarAuditEnabled&&Key.Level>=6)?&AuditMesh:nullptr,
&EnqueueMs,&GpuDispatchMs,Error))
{
GpuFarFreeOutputSlots.push_back(Tile.OutputSlot);
std::fprintf(stderr,"[GpuFarTileError] key=(%d,%d,%d,lod%d): %s\n",
Key.Coord.X,Key.Coord.Y,Key.Coord.Z,Key.Level,Error.c_str());
if(PreparedInputIt!=GpuFarPreparedInputs.end())GpuFarPreparedInputs.erase(PreparedInputIt);
bGpuFarEnabled=false;
break;
}
if(PreparedInputIt!=GpuFarPreparedInputs.end())GpuFarPreparedInputs.erase(PreparedInputIt);
if(bGpuFarAuditEnabled&&GpuFarAudit&&Key.Level>=6)
{
FStandaloneCpuTile AuditTile;AuditTile.Key=Key;
AuditTile.SurfaceVertexCount=static_cast<uint32>(AuditMesh.vertices.size());
AuditTile.Vertices.reserve(AuditMesh.vertices.size());
for(const auto& Vertex:AuditMesh.vertices)
AuditTile.Vertices.push_back({
{Vertex.position[0]*0.01f,Vertex.position[1]*0.01f,Vertex.position[2]*0.01f},
{Vertex.normal[0],Vertex.normal[1],Vertex.normal[2]}});
AuditTile.Indices=std::move(AuditMesh.indices);
GpuFarAudit->AuditTile(AuditTile);
}
Tile.VertexCapacityBytes=static_cast<uint64>(
VoxelForgeGpuFarViewer::PooledOutputVertexCapacityPerTile)*32u;
Tile.GpuDispatchMs=GpuDispatchMs;
GpuFarEnqueueWallSeconds+=EnqueueMs/1000.0;
if(GpuDispatchMs>0.0)
{
GpuFarGpuDispatchMs+=GpuDispatchMs;
GpuFarGpuDispatchMaxMs=std::max(GpuFarGpuDispatchMaxMs,GpuDispatchMs);
Tile.bTimingResolved=true;
}
++GpuFarTilesSubmitted;++Built;
GpuFarTiles.emplace(Key,Tile);
BuiltKeys.push_back(Key);
if(!bGpuFarFirstTileReported)
{
bGpuFarFirstTileReported=true;
std::printf("[GpuFarFirstTile] key=(%d,%d,%d,lod%d) cpu_export_upload_enqueue_ms=%.3f vertex_capacity_mb=%.3f mode=direct-indirect-draw\n",
Key.Coord.X,Key.Coord.Y,Key.Coord.Z,Key.Level,EnqueueMs,
Tile.VertexCapacityBytes/(1024.0*1024.0));
std::fflush(stdout);
}
}
while(Built<32&&!GpuFarQueue.empty()
&&std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-Start).count()<4.0);
if(Built>0)
{
if(bDeferredBatch)
{
FGpuFarBatch Batch;Batch.TileCount=static_cast<uint32>(Built);
std::string BatchError;
if(!VoxelForgeGpuFarViewer::SubmitFarTileBatch(Device,Context,GpuFarShaderPath,
&Batch.CompletionEvent,&Batch.TimingQueries,BatchError))
{
std::fprintf(stderr,"[GpuFarBatchError] submit: %s\n",BatchError.c_str());
bGpuFarEnabled=false;
}
else
{
Batch.SubmittedAt=std::chrono::steady_clock::now();
const double SubmitMs=std::chrono::duration<double,std::milli>(
Batch.SubmittedAt-ColdProcessStart).count();
if(GpuFarFirstSubmitMs<0.0)GpuFarFirstSubmitMs=SubmitMs;
GpuFarLastSubmitMs=SubmitMs;
const uint32 BatchIndex=static_cast<uint32>(GpuFarBatches.size());
GpuFarBatches.push_back(Batch);
for(const FVoxelTileKey& Key:BuiltKeys)
{
auto It=GpuFarTiles.find(Key);
if(It!=GpuFarTiles.end())It->second.BatchIndex=BatchIndex;
}
++GpuFarSubmissionBatches;
GpuFarMaxTilesPerSubmissionBatch=std::max<uint32>(GpuFarMaxTilesPerSubmissionBatch,
static_cast<uint32>(Built));
}
}
else
{
++GpuFarSubmissionBatches;
GpuFarMaxTilesPerSubmissionBatch=std::max<uint32>(GpuFarMaxTilesPerSubmissionBatch,
static_cast<uint32>(Built));
}
}
SampleGpuFarMemory();
const double PumpWallMs=std::chrono::duration<double,std::milli>(
std::chrono::steady_clock::now()-PumpStart).count();
GpuFarPumpWallMs+=PumpWallMs;GpuFarPumpMaxWallMs=std::max(GpuFarPumpMaxWallMs,PumpWallMs);
}
void ToggleFarRenderer()
{
if(!bShapeWorld||!ShapeWorld||!ShapeWorld->hasFarWorld())
{
bGpuFarEnabled=!bGpuFarEnabled;
std::printf("[FarRenderer] GPU far %s; it will take effect when far shapes are ready.\n",
bGpuFarEnabled?"enabled":"disabled");
return;
}
bGpuFarEnabled=!bGpuFarEnabled;
if(bGpuFarEnabled)
{
ScheduleGpuFarTiles(DesiredTiles);
std::vector<FVoxelTileKey> CpuFar;
for(const FVoxelTileKey& Key:DesiredTiles)
if(GpuFarEligibleTiles.contains(Key)&&ResidentTiles.contains(Key))CpuFar.push_back(Key);
for(const FVoxelTileKey& Key:CpuFar)RemoveResidentTile(Key);
}
else
{
GpuFarQueue.clear();GpuFarQueued.clear();GpuFarEligibleTiles.clear();
Streamer->SetDesiredTileFilter(DesiredTiles);
}
std::vector<FVoxelTileKey> ResidentKeys;ResidentKeys.reserve(ResidentTiles.size());
for(const auto& Pair:ResidentTiles)ResidentKeys.push_back(Pair.first);
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
++CrossingIndex;
const FStandaloneStreamingUpdate Update=Streamer->UpdateDesired(
CameraVoxels,ResidentKeys,CrossingIndex);
FCrossingWork& Work=CrossingWork[CrossingIndex];
Work.SubmittedJobs=Update.NewJobs;Work.PendingJobs=Update.NewJobs;
Work.StartTime=std::chrono::steady_clock::now();
std::printf("[FarRenderer] mode=%s cpu_field_jobs=%d gpu_field_ready=%zu gpu_field_queued=%zu (H toggles)\n",
bGpuFarEnabled?"GPU":"CPU",Update.NewJobs,GpuFarTiles.size(),GpuFarQueue.size());
}
void TryCompleteShapePipeline()
{
if(!bShapePipelineActive||InitialNeighborhoodTiles.empty())return;
bool bNeighborhoodUploaded=true;
for(const FVoxelTileKey& Key:InitialNeighborhoodTiles)
if(!ResidentTiles.contains(Key)){bNeighborhoodUploaded=false;break;}
bNeighborhoodUploaded &= DirtyBatchSet.empty();
if(bNeighborhoodUploaded&&!bNeighborhoodReadyReported)
{
bNeighborhoodReadyReported=true;
const double Elapsed=std::chrono::duration<double>(
std::chrono::steady_clock::now()-ColdProcessStart).count();
std::printf("[NeighborhoodReady] %.3fs after cold process start; tiles=%zu/%zu vertices=%llu indices=%llu\n",
Elapsed,InitialNeighborhoodTiles.size(),InitialNeighborhoodTiles.size(),
static_cast<unsigned long long>(TotalVertices),
static_cast<unsigned long long>(TotalIndices));
std::fflush(stdout);
}
if(!bNeighborhoodReadyReported
||!bFullShapeBuildFinished.load(std::memory_order_acquire))return;
if(FullShapeBuildThread.joinable())FullShapeBuildThread.join();
if(!bFullShapeBuildSucceeded||!PendingFullShapeWorld)
{
bShapePipelineActive=false;bGenerationRunning=false;
std::fprintf(stderr,"[ShapePipeline] full shape build failed: %s\n",
FullShapeBuildError.c_str());
PostMessageA(Window,WM_CLOSE,0,0);
return;
}
const double FullShapeSeconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-FullShapeBuildStart).count();
if(Streamer)Streamer->Stop();
Streamer.reset();
ShapeWorld=std::move(PendingFullShapeWorld);
bFarShapeStagePending=false;bShapePipelineActive=false;
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
Streamer=std::make_unique<FStandaloneStreamingGenerator>(*World,WorkerCount,false,nullptr,-1,
false,false,false,false,ShapeWorld.get());
if(bGpuFarEnabled&&ShapeWorld->hasFarWorld())
{
ScheduleGpuFarTiles(DesiredTiles);
if(bGpuFarAuditEnabled)
{
std::vector<FVoxelTileKey> AuditKeys;AuditKeys.reserve(GpuFarEligibleTiles.size());
for(const FVoxelTileKey& Key:DesiredTiles)
if(Key.Level>=6&&GpuFarEligibleTiles.contains(Key))AuditKeys.push_back(Key);
GpuFarAudit=std::make_unique<FFarSurvivalAudit>(*World,*ShapeWorld,AuditKeys,false);
}
std::vector<FVoxelTileKey> CpuResidentNear;
for(const auto& Pair:ResidentTiles)
if(Pair.first.Level<World->FullResClipLevels
&&GpuFarEligibleTiles.contains(Pair.first))CpuResidentNear.push_back(Pair.first);
for(const FVoxelTileKey& Key:CpuResidentNear)RemoveResidentTile(Key);
}
std::vector<FVoxelTileKey> ResidentKeys;ResidentKeys.reserve(ResidentTiles.size());
for(const auto& Pair:ResidentTiles)ResidentKeys.push_back(Pair.first);
++CrossingIndex;
const FStandaloneStreamingUpdate Update=Streamer->Start(CameraVoxels,ResidentKeys,CrossingIndex);
if(Update.DesiredTiles!=static_cast<int32>(DesiredTiles.size()))
{
Streamer->Stop();Streamer.reset();bGenerationRunning=false;
std::fprintf(stderr,"[ShapePipeline] full streamer accepted %d of %zu desired tiles.\n",
Update.DesiredTiles,DesiredTiles.size());
PostMessageA(Window,WM_CLOSE,0,0);
return;
}
FCrossingWork& Work=CrossingWork[CrossingIndex];
Work.SubmittedJobs=Update.NewJobs;Work.PendingJobs=Update.NewJobs;
Work.StartTime=std::chrono::steady_clock::now();
bGenerationRunning=true;
std::printf("[ShapePipelineFullReady] full_shape=%.3fs retained=%d new_jobs=%d workers=%d; filling outward\n",
FullShapeSeconds,Update.RetainedResidentTiles,Update.NewJobs,WorkerCount);
std::fflush(stdout);
}
void MarkBatchDirty(const FStandaloneBatchKey& Key)
{DirtyBatchSet.insert(Key);}
void RefreshResidentSkirtMasks()
{
for(auto& [Key,Resident]:ResidentTiles)
{
if(!DesiredTileSet.contains(Key))continue;
const uint8 NewMask=ComputeVisibleSkirtFaceMask(Key,DesiredTileSet);
if(NewMask==Resident.ActiveSkirtFaceMask)continue;
Resident.ActiveSkirtFaceMask=NewMask;
MarkBatchDirty(BatchForTile(Key));
}
}
static bool TileKeyLess(const FVoxelTileKey& A,const FVoxelTileKey& B)
{
if(A.Level!=B.Level)return A.Level<B.Level;
if(A.Coord.Z!=B.Coord.Z)return A.Coord.Z<B.Coord.Z;
if(A.Coord.Y!=B.Coord.Y)return A.Coord.Y<B.Coord.Y;
return A.Coord.X<B.Coord.X;
}
void RemoveResidentTile(const FVoxelTileKey& Key)
{
auto Resident=ResidentTiles.find(Key);
if(Resident==ResidentTiles.end())return;
const FStandaloneBatchKey Batch=BatchForTile(Key);
auto Members=BatchMembers.find(Batch);
if(Members!=BatchMembers.end())
{
auto& Items=Members->second;
Items.erase(std::remove(Items.begin(),Items.end(),Key),Items.end());
if(Items.empty())BatchMembers.erase(Members);
}
MarkBatchDirty(Batch);
ResidentTiles.erase(Resident);
}
void RecenterStreaming()
{
if(!World||!Streamer)return;
const FVector CameraVoxels(Position.X*4.0,Position.Y*4.0,Position.Z*4.0);
FStandaloneDesiredTileSet NewDesired=StandaloneWorldMesher::BuildDesiredSet(*World,CameraVoxels);
if(bShapeWorld&&ShapeWorld)
{
const auto CoreTiles=ShapeWorld->desiredTiles(
{CameraVoxels.X,CameraVoxels.Y,CameraVoxels.Z});
NewDesired.Tiles.clear();NewDesired.Tiles.reserve(CoreTiles.size());
for(const auto& Key:CoreTiles)
NewDesired.Tiles.emplace_back(
FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
}
if(NewDesired.CenterChunk==BuildTargetChunk)return;
const FIntVector Previous=BuildTargetChunk;
const FIntVector CenterDelta(NewDesired.CenterChunk.X-Previous.X,
NewDesired.CenterChunk.Y-Previous.Y,NewDesired.CenterChunk.Z-Previous.Z);
if(FlightTargetCrossings>0&&bFlightStarted&&!bFlightFinished)
{
++FlightObservedCrossings;
if(CenterDelta.X!=0||CenterDelta.Y!=1||CenterDelta.Z!=0)
bFlightCrossingsValid=false;
}
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> NewSet;
NewSet.reserve(NewDesired.Tiles.size()*2+1);
for(const FVoxelTileKey& Key:NewDesired.Tiles)NewSet.insert(Key);
std::vector<FVoxelTileKey> Leavers;
for(const auto& Pair:ResidentTiles)if(!NewSet.contains(Pair.first))Leavers.push_back(Pair.first);
const auto CrossingStart=std::chrono::steady_clock::now();
double PageCompileSeconds=0.0;
uint64 PageCoveredTiles=0;
VoxelForgeCore::TileRegionCompileStats PageStats;
const uint64 NextCrossing=CrossingIndex+1;
FCrossingWork& NextWork=CrossingWork[NextCrossing];
NextWork.StartTime=CrossingStart;
for(const FVoxelTileKey& Key:NewDesired.Tiles)
if(NewSet.contains(Key)&&!ResidentTiles.contains(Key))
{
NextWork.NearestNewTile=Key;
NextWork.bHasNearestNewTile=true;
break;
}
if(bShapeWorld&&ShapeWorld)
{
std::vector<VoxelForgeCore::TileKey> NewCoreTiles;
NewCoreTiles.reserve(NewDesired.Tiles.size());
for(const FVoxelTileKey& Key:NewDesired.Tiles)
if(!ResidentTiles.contains(Key))
NewCoreTiles.push_back({{Key.Coord.X,Key.Coord.Y,Key.Coord.Z},Key.Level});
std::string PageError;
size_t CompiledPageCount=0;
if(!ShapeWorld->compileTileRegion(NewCoreTiles,
static_cast<uint32>(std::clamp(WorkerCount,1,8)),CoreScheduler,PageError,
&CompiledPageCount,&PageStats,true))
{
std::fprintf(stderr,"[ShapeRegionPage] compile failed at center=(%d,%d,%d): %s\n",
NewDesired.CenterChunk.X,NewDesired.CenterChunk.Y,NewDesired.CenterChunk.Z,
PageError.c_str());
return;
}
PageCoveredTiles=static_cast<uint64>(CompiledPageCount);
std::vector<VoxelForgeCore::TileKey> CoreDesired;
CoreDesired.reserve(NewDesired.Tiles.size());
for(const FVoxelTileKey& Key:NewDesired.Tiles)
CoreDesired.push_back({{Key.Coord.X,Key.Coord.Y,Key.Coord.Z},Key.Level});
ShapeWorld->retainTileRegions(CoreDesired);
for(const FVoxelTileKey& Key:Leavers)DeferredLeaverTiles.insert(Key);
const double PageSeconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-CrossingStart).count();
PageCompileSeconds=PageStats.wallSeconds;
std::printf("[ShapeRegionPage] region_mode=analytic-lod-slab center=(%d,%d,%d) requested_tiles=%zu page_covered_tiles=%llu regions=%zu lattice_nodes=%llu worker_limit=%d shape=%.4fs intervals_signs=%.4fs detail=%.4fs core_worker_sum=%.4fs seconds=%.4f retained_resident=%zu deferred_leavers=%zu\n",
NewDesired.CenterChunk.X,NewDesired.CenterChunk.Y,NewDesired.CenterChunk.Z,
NewCoreTiles.size(),static_cast<unsigned long long>(PageCoveredTiles),
PageStats.regionsBuilt,static_cast<unsigned long long>(PageStats.latticeNodes),
std::clamp(WorkerCount,1,8),PageStats.shapeSeconds,PageStats.intervalSeconds,
PageStats.surfaceSeconds,PageStats.workerSeconds,PageSeconds,
ResidentTiles.size()-std::min(ResidentTiles.size(),Leavers.size()),Leavers.size());
}
else
{
for(const FVoxelTileKey& Key:Leavers)RemoveResidentTile(Key);
}
DesiredTiles=NewDesired.Tiles;
DesiredTileSet=std::move(NewSet);
for(auto It=GpuFarTiles.begin();It!=GpuFarTiles.end();)
{
if(DesiredTileSet.contains(It->first)){++It;continue;}
GpuFarFreeOutputSlots.push_back(It->second.OutputSlot);
ReleaseGpuFarTile(It->second);
It=GpuFarTiles.erase(It);
}
ScheduleGpuFarTiles(DesiredTiles);
RefreshResidentSkirtMasks();
for(int32 I=0;I<=MaxLevels;++I)DesiredByLevel[I]=0;
for(const FVoxelTileKey& Tile:DesiredTiles)++DesiredByLevel[Tile.Level];
std::vector<FVoxelTileKey> ResidentKeys;ResidentKeys.reserve(ResidentTiles.size());
for(const auto& Pair:ResidentTiles)
if(DesiredTileSet.contains(Pair.first))ResidentKeys.push_back(Pair.first);
++CrossingIndex;
const FStandaloneStreamingUpdate Update=Streamer->UpdateDesiredWithSet(
std::move(NewDesired),ResidentKeys,CrossingIndex);
for(const auto& Pair:Update.CancelledByCrossing)
{
FCrossingWork& Work=CrossingWork[Pair.first];
Work.PendingJobs=Work.PendingJobs>=Pair.second?Work.PendingJobs-Pair.second:0;
Work.CancelledQueuedJobs+=Pair.second;
}
FCrossingWork& Work=CrossingWork[CrossingIndex];
Work.SubmittedJobs=Update.NewJobs;Work.PendingJobs=Update.NewJobs;
Work.PageCoveredTiles=PageCoveredTiles;Work.CorePageSeconds=PageCompileSeconds;
Work.CorePageWorkerSeconds=PageStats.workerSeconds;
Work.PageRegions=PageStats.regionsBuilt;Work.PageLatticeNodes=PageStats.latticeNodes;
BuildTargetChunk=Update.CenterChunk;bGenerationRunning=true;
std::printf("[ChunkCrossing] id=%llu center=(%d,%d,%d) delta=(%d,%d,%d) desired=%d retained=%d new_jobs=%d deferred_resident=%zu cancelled_queued=%d full_detail=%d\n",
static_cast<unsigned long long>(CrossingIndex),Update.CenterChunk.X,Update.CenterChunk.Y,Update.CenterChunk.Z,
Update.CenterChunk.X-Previous.X,Update.CenterChunk.Y-Previous.Y,Update.CenterChunk.Z-Previous.Z,
Update.DesiredTiles,Update.RetainedResidentTiles,Update.NewJobs,
bShapeWorld?Leavers.size():0,
Update.CancelledQueuedJobs,Update.FullResTiles);
std::fflush(stdout);
ReportCrossingWork();
}
bool RebuildBatch(const FStandaloneBatchKey& Key)
{
auto MembersIt=BatchMembers.find(Key);
auto Existing=StreamingBatches.find(Key);
if(MembersIt==BatchMembers.end()||MembersIt->second.empty())
{
if(Existing!=StreamingBatches.end())
{
TotalVertices-=Existing->second.VertexCount;TotalIndices-=Existing->second.IndexCount;
if(Existing->second.VertexBuffer)Existing->second.VertexBuffer->Release();
if(Existing->second.IndexBuffer)Existing->second.IndexBuffer->Release();
StreamingBatches.erase(Existing);
}
return true;
}
std::vector<FVoxelTileKey> Members=MembersIt->second;
std::sort(Members.begin(),Members.end(),TileKeyLess);
size_t VertexCount=0,IndexCount=0;
for(const FVoxelTileKey& Tile:Members)
{
const auto It=ResidentTiles.find(Tile);if(It==ResidentTiles.end())continue;
const FResidentTileMesh& Resident=It->second;
VertexCount+=Resident.Vertices.size();
if(Resident.TriangleSkirtFaceMasks.size()==Resident.Indices.size()/3)
{
for(const uint8 Faces:Resident.TriangleSkirtFaceMasks)
if(Faces==0||(Faces&Resident.ActiveSkirtFaceMask)!=0)IndexCount+=3;
}
else IndexCount+=Resident.Indices.size();
}
if(VertexCount==0||IndexCount==0)
{
if(Existing!=StreamingBatches.end())
{
TotalVertices-=Existing->second.VertexCount;TotalIndices-=Existing->second.IndexCount;
if(Existing->second.VertexBuffer)Existing->second.VertexBuffer->Release();
if(Existing->second.IndexBuffer)Existing->second.IndexBuffer->Release();
StreamingBatches.erase(Existing);
}
return true;
}
if(VertexCount>std::numeric_limits<uint32>::max()||IndexCount>std::numeric_limits<UINT>::max())
{std::fprintf(stderr,"LOD %d batch exceeded D3D11 limits.\n",Key.Level);return false;}
std::vector<FGpuVertex> Vertices;Vertices.reserve(VertexCount);
std::vector<uint32> Indices;Indices.reserve(IndexCount);
for(const FVoxelTileKey& Tile:Members)
{
const auto It=ResidentTiles.find(Tile);if(It==ResidentTiles.end())continue;
const uint32 Base=static_cast<uint32>(Vertices.size());
const FResidentTileMesh& Resident=It->second;
for(const FStandaloneCpuVertex& V:Resident.Vertices)
Vertices.push_back({{V.Position[0],V.Position[1],V.Position[2]},{V.Normal[0],V.Normal[1],V.Normal[2]}});
const bool bHasFaceMasks=Resident.TriangleSkirtFaceMasks.size()==Resident.Indices.size()/3;
for(size_t Triangle=0;Triangle<Resident.Indices.size()/3;++Triangle)
{
if(bHasFaceMasks)
{
const uint8 Faces=Resident.TriangleSkirtFaceMasks[Triangle];
if(Faces!=0&&(Faces&Resident.ActiveSkirtFaceMask)==0)continue;
}
const size_t Start=Triangle*3;
Indices.push_back(Base+Resident.Indices[Start]);
Indices.push_back(Base+Resident.Indices[Start+1]);
Indices.push_back(Base+Resident.Indices[Start+2]);
}
}
FStreamingGpuBatch NewBatch;
const bool bVertex=MakeBuffer(&NewBatch.VertexBuffer,Vertices.data(),Vertices.size()*sizeof(FGpuVertex),D3D11_BIND_VERTEX_BUFFER);
const bool bIndex=bVertex&&MakeBuffer(&NewBatch.IndexBuffer,Indices.data(),Indices.size()*sizeof(uint32),D3D11_BIND_INDEX_BUFFER);
if(!bIndex)
{
if(NewBatch.VertexBuffer)NewBatch.VertexBuffer->Release();
std::fprintf(stderr,"D3D11 upload failed for LOD %d batch (%d,%d,%d).\n",Key.Level,Key.X,Key.Y,Key.Z);
return false;
}
NewBatch.IndexCount=static_cast<UINT>(Indices.size());NewBatch.VertexCount=Vertices.size();
if(Existing!=StreamingBatches.end())
{
TotalVertices-=Existing->second.VertexCount;TotalIndices-=Existing->second.IndexCount;
if(Existing->second.VertexBuffer)Existing->second.VertexBuffer->Release();
if(Existing->second.IndexBuffer)Existing->second.IndexBuffer->Release();
Existing->second=NewBatch;
}
else StreamingBatches.emplace(Key,NewBatch);
TotalVertices+=NewBatch.VertexCount;TotalIndices+=NewBatch.IndexCount;
return true;
}
void UploadDirtyBatches()
{
if(DirtyBatchSet.empty())return;
std::vector<FStandaloneBatchKey> Dirty(DirtyBatchSet.begin(),DirtyBatchSet.end());
const FIntVector Center=Streamer?Streamer->CenterChunk():BuildTargetChunk;
auto Distance=[&](const FStandaloneBatchKey& K)
{
const double Scale=static_cast<double>(1<<K.Level);
const double DX=(K.X*8.0+4.0)*Scale-Center.X;
const double DY=(K.Y*8.0+4.0)*Scale-Center.Y;
const double DZ=(K.Z+0.5)*Scale-Center.Z;
return DX*DX+DY*DY+DZ*DZ;
};
std::sort(Dirty.begin(),Dirty.end(),[&](const auto& A,const auto& B)
{const double DA=Distance(A),DB=Distance(B);return DA==DB?A.Level<B.Level:DA<DB;});
const auto Start=std::chrono::steady_clock::now();int32 Uploaded=0;
for(const FStandaloneBatchKey& Key:Dirty)
{
if(Uploaded>=MaxBatchUploadsPerFrame)break;
if(Uploaded>0&&BatchUploadBudgetMilliseconds>0.0
&&std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-Start).count()>=BatchUploadBudgetMilliseconds)break;
if(!DirtyBatchSet.contains(Key))continue;
if(RebuildBatch(Key)){DirtyBatchSet.erase(Key);++Uploaded;}
}
}
bool IsFullDetailUploaded()
{
if(!Streamer||World->FullResClipLevels<=0)return false;
int32 DesiredFullRes=0,ReadyFullRes=0;
for(const FVoxelTileKey& Key:DesiredTiles)
{
if(Key.Level>=World->FullResClipLevels)continue;
++DesiredFullRes;
if(IsRenderedTileReady(Key))++ReadyFullRes;
}
if(ReadyFullRes!=DesiredFullRes)return false;
for(const FStandaloneBatchKey& Key:DirtyBatchSet)if(Key.Level<World->FullResClipLevels)return false;
return true;
}
void ReportTileTimings()
{
for(int32 L=0;L<=World->MaxClipLevel;++L)
{
if(GeneratedByLevel[L]<static_cast<uint64>(DesiredByLevel[L])||DesiredByLevel[L]==0)continue;
std::vector<double>& Times=TileSecondsByLevel[L];if(Times.empty())continue;
std::sort(Times.begin(),Times.end());
const double Average=WorkerSecondsByLevel[L]/static_cast<double>(GeneratedByLevel[L]);
const double P50=Times[(Times.size()-1)*50/100];
const double P95=Times[(Times.size()-1)*95/100];
std::printf("[TileTiming] LOD=%d generated=%llu target=%d samples=%.2fM worker_sum=%.3fs avg=%.3fms p50=%.3fms p95=%.3fms\n",
L,static_cast<unsigned long long>(GeneratedByLevel[L]),DesiredByLevel[L],
static_cast<double>(SamplesByLevel[L])/1.0e6,WorkerSecondsByLevel[L],Average*1000.0,P50*1000.0,P95*1000.0);
if(bProfileAttribution)
{
std::printf("[TileProfile] LOD=%d",L);
for(size_t I=0;I<VoxelDensityProfile::BucketCount;++I)
{
const double Ms=static_cast<double>(ProfileCyclesByLevel[L][I])
*FPlatformTime::GetSecondsPerCycle64()*1000.0;
if(Ms>0.001)std::printf(" %s=%.3fms",
VoxelDensityProfile::BucketName(static_cast<VoxelDensityProfile::EBucket>(I)),Ms);
}
std::printf("\n");
}
Times.clear();
}
}
void ReportCrossingWork()
{
for(auto& Pair:CrossingWork)
{
FCrossingWork& Work=Pair.second;
if(Work.bReported||Work.PendingJobs!=0)continue;
Work.bReported=true;
const double AverageMs=Work.FinishedJobs>0
?Work.WorkerSeconds*1000.0/static_cast<double>(Work.FinishedJobs):0.0;
Work.WallSeconds=Work.StartTime.time_since_epoch().count()!=0
?std::chrono::duration<double>(std::chrono::steady_clock::now()-Work.StartTime).count():0.0;
const double NearestReadyMs=Work.NearestReadySeconds>=0.0
?Work.NearestReadySeconds*1000.0:-1.0;
std::printf("[ChunkCrossingWork] id=%llu submitted=%llu finished=%llu generated=%llu cancelled_queued=%llu stale=%llu samples=%.2fM page_covered_tiles=%llu page_regions=%llu page_nodes=%llu core_page=%.4fs core_page_worker=%.4fs nearest_ready=%.3fms nearest_tile=(%d,%d,%d,lod%d) worker_sum=%.3fs wall=%.3fs avg=%.3fms\n",
static_cast<unsigned long long>(Pair.first),
static_cast<unsigned long long>(Work.SubmittedJobs),
static_cast<unsigned long long>(Work.FinishedJobs),
static_cast<unsigned long long>(Work.Tiles),
static_cast<unsigned long long>(Work.CancelledQueuedJobs),
static_cast<unsigned long long>(Work.StaleResults),
static_cast<double>(Work.Samples)/1.0e6,
static_cast<unsigned long long>(Work.PageCoveredTiles),
static_cast<unsigned long long>(Work.PageRegions),
static_cast<unsigned long long>(Work.PageLatticeNodes),
Work.CorePageSeconds,Work.CorePageWorkerSeconds,NearestReadyMs,
Work.NearestNewTile.Coord.X,Work.NearestNewTile.Coord.Y,
Work.NearestNewTile.Coord.Z,Work.NearestNewTile.Level,
Work.WorkerSeconds,Work.WallSeconds,AverageMs);
for(int32 Level=0;Level<=MaxLevels;++Level)
if(Work.TilesByLevel[Level]>0)
std::printf("[ChunkCrossingLevel] id=%llu lod=%d tiles=%llu samples=%.3fM worker_sum=%.4fs avg=%.3fms\n",
static_cast<unsigned long long>(Pair.first),Level,
static_cast<unsigned long long>(Work.TilesByLevel[Level]),
static_cast<double>(Work.SamplesByLevel[Level])/1.0e6,
Work.WorkerSecondsByLevel[Level],
Work.WorkerSecondsByLevel[Level]*1000.0/
static_cast<double>(Work.TilesByLevel[Level]));
}
}
void PumpGeneration()
{
if(bRebuildPending){StartGeneration();return;}
if(!Streamer)return;
std::vector<FStandaloneCpuTile> Ready=Streamer->TakeReady();
for(FStandaloneCpuTile& Tile:Ready)
{
const int32 Level=Tile.Key.Level;
FCrossingWork& Crossing=CrossingWork[Tile.RequestedCrossing];
if(Crossing.PendingJobs>0)--Crossing.PendingJobs;
++Crossing.FinishedJobs;Crossing.Samples+=Tile.DensitySamples;Crossing.WorkerSeconds+=Tile.WorkerSeconds;
if(Level>=0&&Level<=MaxLevels)
{
++Crossing.TilesByLevel[Level];
Crossing.SamplesByLevel[Level]+=Tile.DensitySamples;
Crossing.WorkerSecondsByLevel[Level]+=Tile.WorkerSeconds;
}
if(Crossing.bHasNearestNewTile&&Tile.Key==Crossing.NearestNewTile
&&Crossing.NearestReadySeconds<0.0)
Crossing.NearestReadySeconds=std::chrono::duration<double>(
Tile.CompletedAt-Crossing.StartTime).count();
if(!Streamer->IsDesired(Tile.Key)||ResidentTiles.contains(Tile.Key))
{++Crossing.StaleResults;continue;}
++Crossing.Tiles;
++GeneratedByLevel[Level];SamplesByLevel[Level]+=Tile.DensitySamples;WorkerSecondsByLevel[Level]+=Tile.WorkerSeconds;
if(bProfileAttribution)for(size_t I=0;I<Tile.ProfileCycles.size();++I)
ProfileCyclesByLevel[Level][I]+=Tile.ProfileCycles[I];
TileSecondsByLevel[Level].push_back(Tile.WorkerSeconds);
FResidentTileMesh Resident;Resident.Vertices=std::move(Tile.Vertices);Resident.Indices=std::move(Tile.Indices);
Resident.TriangleSkirtFaceMasks=std::move(Tile.TriangleSkirtFaceMasks);
Resident.ActiveSkirtFaceMask=ComputeVisibleSkirtFaceMask(Tile.Key,DesiredTileSet);
Resident.Samples=Tile.DensitySamples;Resident.WorkerSeconds=Tile.WorkerSeconds;
ResidentTiles.emplace(Tile.Key,std::move(Resident));
const FStandaloneBatchKey Batch=BatchForTile(Tile.Key);
BatchMembers[Batch].push_back(Tile.Key);MarkBatchDirty(Batch);
}
ReportCrossingWork();
UploadDirtyBatches();
if(!DeferredLeaverTiles.empty()&&DirtyBatchSet.empty())
{
bool bDesiredResident=true;
for(const FVoxelTileKey& Key:DesiredTiles)
if(!IsRenderedTileReady(Key)){bDesiredResident=false;break;}
if(bDesiredResident)
{
std::vector<FVoxelTileKey> ReadyToDrop;
for(const FVoxelTileKey& Key:DeferredLeaverTiles)
{
if(Streamer->IsDesired(Key))continue;
if(ResidentTiles.contains(Key))ReadyToDrop.push_back(Key);
}
for(const FVoxelTileKey& Key:ReadyToDrop)RemoveResidentTile(Key);
DeferredLeaverTiles.clear();
}
}
if(bShapePipelineActive)TryCompleteShapePipeline();
if(FlightTargetCrossings>0&&bFlightFinished&&!bFlightClosePosted
&&DirtyBatchSet.empty()&&DeferredLeaverTiles.empty())
{
bool bAllFlightWorkReported=true;
bool bCrossingLatencyUnderTarget=true;
double MaxCrossingWallSeconds=0.0,MaxWorkerCpuSeconds=0.0;
std::vector<double> NearestReadyMilliseconds;
for(uint64 Crossing=FlightStartCrossingIndex+1;
Crossing<=CrossingIndex;++Crossing)
{
const auto It=CrossingWork.find(Crossing);
if(It==CrossingWork.end()||!It->second.bReported)
{bAllFlightWorkReported=false;continue;}
const FCrossingWork& Work=It->second;
MaxCrossingWallSeconds=std::max(MaxCrossingWallSeconds,Work.WallSeconds);
MaxWorkerCpuSeconds=std::max(MaxWorkerCpuSeconds,Work.WorkerSeconds);
if(Work.WallSeconds>=0.200)bCrossingLatencyUnderTarget=false;
if(Work.NearestReadySeconds>=0.0)
NearestReadyMilliseconds.push_back(Work.NearestReadySeconds*1000.0);
}
if(bAllFlightWorkReported)
{
bFlightClosePosted=true;
const double Elapsed=std::chrono::duration<double>(
std::chrono::steady_clock::now()-FlightStartTime).count();
const uint64 CacheHits=Streamer?Streamer->GetCacheHits():0;
std::size_t DesiredResidentCount=0;
for(const FVoxelTileKey& Key:DesiredTiles)
if(IsRenderedTileReady(Key))++DesiredResidentCount;
std::sort(NearestReadyMilliseconds.begin(),NearestReadyMilliseconds.end());
const auto Percentile=[&](std::size_t Percent)
{
if(NearestReadyMilliseconds.empty())return -1.0;
const std::size_t Index=(NearestReadyMilliseconds.size()-1)*Percent/100;
return NearestReadyMilliseconds[Index];
};
const double NearestMaximum=NearestReadyMilliseconds.empty()?-1.0:
NearestReadyMilliseconds.back();
const std::size_t MissingDesired=DesiredTiles.size()-DesiredResidentCount;
const bool bPass=FlightObservedCrossings==FlightTargetCrossings
&&bFlightCrossingsValid&&CacheHits==0&&bCrossingLatencyUnderTarget
&&MissingDesired==0&&DeferredLeaverTiles.empty()&&DirtyBatchSet.empty();
std::printf("[FlightBenchmarkComplete] crossings=%d/%d speed=%.2fm/s elapsed=%.3fs cache_hits=%llu crossing_deltas=%s nearest_ready_p50=%.3fms nearest_ready_p95=%.3fms nearest_ready_max=%.3fms max_crossing_wall=%.3fs max_worker_cpu_sum=%.3fs resident=%zu/%zu missing_tiles=%zu deferred_leavers=%zu uploads_drained=%s status=%s\n",
FlightObservedCrossings,FlightTargetCrossings,FlightSpeedMps,Elapsed,
static_cast<unsigned long long>(CacheHits),
bFlightCrossingsValid?"unit-+Y":"invalid",
Percentile(50),Percentile(95),NearestMaximum,MaxCrossingWallSeconds,
MaxWorkerCpuSeconds,DesiredResidentCount,DesiredTiles.size(),MissingDesired,
DeferredLeaverTiles.size(),DirtyBatchSet.empty()?"yes":"no",
bPass?"PASS":"FAIL");
std::fflush(stdout);
PostMessageA(Window,WM_CLOSE,0,0);
}
}
if(!bShapePipelineActive&&!bFullDetailReported&&IsFullDetailUploaded())
{
bFullDetailReported=true;
const double Elapsed=std::chrono::duration<double>(std::chrono::steady_clock::now()-ColdProcessStart).count();
const std::size_t DesiredNear=static_cast<std::size_t>(std::count_if(
DesiredTiles.begin(),DesiredTiles.end(),[&](const FVoxelTileKey& Key)
{return Key.Level<World->FullResClipLevels;}));
std::printf("[FullDetailReady] %.3f s after cold process start; rendered=%zu/%zu tiles through LOD%d.\n",
Elapsed,DesiredNear,DesiredNear,World->FullResClipLevels-1);
std::printf("[ColdTimeline] event=near_all_tiles_ready at_ms=%.3f waits_for=all_%zu_LOD0_1_gpu_or_cpu_tiles\n",
Elapsed*1000.0,DesiredNear);
ReportTileTimings();std::fflush(stdout);
StartFarShapeGeneration();
}
size_t DesiredResidentCount=0;
for(const FVoxelTileKey& Key:DesiredTiles)
if(IsRenderedTileReady(Key))++DesiredResidentCount;
if(!bInitialClipmapReported&&DesiredResidentCount==DesiredTiles.size()&&DirtyBatchSet.empty())
{
bInitialClipmapReported=true;
const double Elapsed=std::chrono::duration<double>(std::chrono::steady_clock::now()-ColdProcessStart).count();
std::printf("[InitialClipmapReady] %.3f s after cold process start; %zu tiles, %llu vertices, %llu indices, %zu GPU batches.\n",
Elapsed,DesiredResidentCount,static_cast<unsigned long long>(TotalVertices),
static_cast<unsigned long long>(TotalIndices),StreamingBatches.size());
std::printf("[ColdTimeline] event=whole_clipmap_ready at_ms=%.3f waits_for=%zu_GPU_tiles_plus_CPU_fallback_and_uploads\n",
Elapsed*1000.0,GpuFarEligibleTiles.size());
if(bGpuFarEnabled)
{
SampleGpuFarMemory();
const double AverageGpuMs=GpuFarTilesSubmitted
?GpuFarGpuDispatchMs/static_cast<double>(GpuFarTilesSubmitted):0.0;
std::printf("[GpuFarTiming] submitted_tiles=%llu submission_batches=%llu max_tiles_per_batch=%u pooled_output_reserve_wall_ms=%.3f cpu_input_prepare_wall_ms=%.3f cpu_input_worker_sum_ms=%.3f cpu_upload_enqueue_sum_ms=%.3f gpu_dispatch_timestamp_total_ms=%.3f gpu_dispatch_mean_per_tile_ms=%.6f gpu_dispatch_max_tile_ms=%.6f gpu_submission_span_total_ms=%.3f gpu_submission_span_max_batch_ms=%.3f frame_budget_90hz_ms=11.111\n",
static_cast<unsigned long long>(GpuFarTilesSubmitted),
static_cast<unsigned long long>(GpuFarSubmissionBatches),GpuFarMaxTilesPerSubmissionBatch,
GpuFarPoolReserveMs,GpuFarPreparationWallMs,GpuFarPreparationWorkerMs,
GpuFarEnqueueWallSeconds*1000.0,
GpuFarGpuDispatchMs,AverageGpuMs,GpuFarGpuDispatchMaxMs,
GpuFarSubmissionSpanMs,GpuFarSubmissionSpanMaxMs);
std::printf("[GpuFarTimeline] pump_calls=%llu pump_first_ms=%.3f pump_last_ms=%.3f pump_gap_sum_ms=%.3f pump_gap_max_ms=%.3f pump_cpu_sum_ms=%.3f pump_cpu_max_ms=%.3f submit_first_ms=%.3f submit_last_ms=%.3f completion_polls=%llu completion_first_ms=%.3f completion_last_ms=%.3f queue_envelope_ms=%.3f gpu_busy_ms=%.3f estimated_idle_or_poll_ms=%.3f\n",
static_cast<unsigned long long>(GpuFarPumpCalls),GpuFarFirstPumpMs,GpuFarLastPumpMs,
GpuFarPumpGapMs,GpuFarPumpGapMaxMs,GpuFarPumpWallMs,GpuFarPumpMaxWallMs,
GpuFarFirstSubmitMs,GpuFarLastSubmitMs,
static_cast<unsigned long long>(GpuFarCompletionPolls),GpuFarFirstCompletionPollMs,
GpuFarLastCompletionPollMs,
GpuFarFirstSubmitMs>=0.0&&GpuFarLastCompletionPollMs>=0.0
?GpuFarLastCompletionPollMs-GpuFarFirstSubmitMs:0.0,
GpuFarSubmissionSpanMs,
GpuFarFirstSubmitMs>=0.0&&GpuFarLastCompletionPollMs>=0.0
?std::max(0.0,GpuFarLastCompletionPollMs-GpuFarFirstSubmitMs-GpuFarSubmissionSpanMs):0.0);
std::printf("[GpuFarMemory] dxgi_local_sampled_peak_mb=%.1f dxgi_local_budget_mb=%.1f\n",
GpuFarLocalMemoryPeakBytes/(1024.0*1024.0),
GpuFarLocalMemoryBudgetBytes/(1024.0*1024.0));
}
ReportTileTimings();std::fflush(stdout);
if(bQuitAfterClipmap&&CapturePath.empty())PostMessageA(Window,WM_CLOSE,0,0);
}
if(bInitialClipmapReported&&bGpuFarAuditEnabled&&GpuFarAudit&&!bGpuFarAuditReported)
{
GpuFarAudit->Finalize();GpuFarAudit->Print();
bGpuFarAuditReported=true;
std::printf("[GpuFarSurvivalAudit] mesh_source=GPU field_readback=required status=%s\n",
GpuFarAudit->Passing()?"PASS":"FAIL");
std::fflush(stdout);
if(bQuitAfterClipmap&&CapturePath.empty())PostMessageA(Window,WM_CLOSE,0,0);
}
bGenerationRunning=DesiredResidentCount!=DesiredTiles.size()||!DirtyBatchSet.empty()
||(bGpuFarEnabled&&!GpuFarQueue.empty());
}
void CaptureRenderedFrame()
{
const bool bReadyToCapture=bCaptureAfterClipmap?bInitialClipmapReported:IsFullDetailUploaded();
if(CapturePath.empty()||bAutoCaptureWritten||!bReadyToCapture)return;
bAutoCaptureWritten=SaveBackBufferPng(CapturePath);
if(bAutoCaptureWritten)
{
const double Elapsed=std::chrono::duration<double>(std::chrono::steady_clock::now()-GenerationStart).count();
std::printf("Back-buffer capture saved: %s (%.3f s after generation start; full detail uploaded).\n",CapturePath.c_str(),Elapsed);
std::fflush(stdout);PostMessageA(Window,WM_CLOSE,0,0);
}
else std::fprintf(stderr,"Back-buffer capture failed: %s\n",CapturePath.c_str());
}
void Capture(bool bOn)
{
bCaptured=bOn;
if(bOn){SetCapture(Window);ShowCursor(FALSE);GetCursorPos(&LastMouse);POINT C{Width/2,Height/2};ClientToScreen(Window,&C);SetCursorPos(C.x,C.y);}
else{ReleaseCapture();ShowCursor(TRUE);}
}
void UpdateTitle()
{
uint64 VisibleIndices=0;for(const auto& Pair:StreamingBatches)if(bShowLevel[Pair.first.Level])VisibleIndices+=Pair.second.IndexCount;
std::ostringstream S;S<<"VoxelForge standalone | seed "<<Seed<<" | "<<(bShapeWorld?"shape-interval owner world":(bRoundTunnels?"round/winding research tunnels":"base world"))
<<(bRoundTunnels?(bRoundTunnelEnhanced?" (detailed walls)":" (legacy walls)"):"")
<<" | "<<VisibleIndices/3<<" tris | "<<FrameMs<<" ms | field "<<(bGpuFarEnabled?"GPU":"CPU")
<<" | "<<(bGenerationRunning?"generating":"ready")
<<" | pos "<<std::fixed<<std::setprecision(1)<<Position.X<<", "<<Position.Y<<", "<<Position.Z<<" m";
SetWindowTextA(Window,S.str().c_str());
}
void Draw()
{
const auto DrawStart=std::chrono::steady_clock::now();
const double InterDrawGapMs=LastDrawEndAt.time_since_epoch().count()!=0
?std::chrono::duration<double,std::milli>(DrawStart-LastDrawEndAt).count():0.0;
PumpGeneration();
const auto CpuPumpEnd=std::chrono::steady_clock::now();
PumpGpuFarGeneration();
const auto GpuPumpEnd=std::chrono::steady_clock::now();
const auto Now=std::chrono::steady_clock::now();
if(FlightTargetCrossings>0&&bFullDetailReported&&!bFlightStarted)
{
bFlightStarted=true;FlightStartTime=Now;FlightStartPosition=Position;
FlightStartCrossingIndex=CrossingIndex;FlightObservedCrossings=0;
bFlightCrossingsValid=true;
std::printf("[FlightBenchmarkStart] crossings=%d speed=%.2fm/s direction=+Y start=(%.2f,%.2f,%.2f)m cache_mode=none\n",
FlightTargetCrossings,FlightSpeedMps,Position.X,Position.Y,Position.Z);
std::fflush(stdout);
}
if(FlightTargetCrossings>0&&bFlightStarted&&!bFlightFinished)
{
const double Elapsed=std::chrono::duration<double>(Now-FlightStartTime).count();
Position=V3(FlightStartPosition.X,FlightStartPosition.Y+
static_cast<float>(FlightSpeedMps*Elapsed),FlightStartPosition.Z);
if(FlightObservedCrossings>=FlightTargetCrossings)
{
bFlightFinished=true;
std::printf("[FlightBenchmarkMove] movement stopped after %d center-chunk crossings; waiting for new nearest tiles, meshes and uploads.\n",
FlightObservedCrossings);
std::fflush(stdout);
}
}
const float Dt=std::clamp(std::chrono::duration<float>(Now-PreviousFrame).count(),0.0f,0.1f);
PreviousFrame=Now;FrameMs=Dt*1000.0;
const V3 F=Forward(),R=Normalize(Cross(F,{0,0,1})),U=Normalize(Cross(R,F));
const float Step=MoveSpeed*Dt*(Keys[VK_SHIFT]?4.0f:1.0f);
if(Keys['W'])Position=Add(Position,Mul(F,Step));if(Keys['S'])Position=Sub(Position,Mul(F,Step));
if(Keys['A'])Position=Sub(Position,Mul(R,Step));if(Keys['D'])Position=Add(Position,Mul(R,Step));
if(Keys[VK_SPACE]||Keys['E'])Position.Z+=Step;if(Keys[VK_CONTROL]||Keys['Q'])Position.Z-=Step;
if(Streamer&&NeedsRecenter(BuildTargetChunk))RecenterStreaming();
const float Clear[4]={0.055f,0.075f,0.105f,1.0f};
Context->OMSetRenderTargets(1,&RenderTarget,DepthView);Context->ClearRenderTargetView(RenderTarget,Clear);
Context->ClearDepthStencilView(DepthView,D3D11_CLEAR_DEPTH,1.0f,0);
D3D11_VIEWPORT Viewport{0,0,static_cast<float>(Width),static_cast<float>(Height),0,1};Context->RSSetViewports(1,&Viewport);
Context->RSSetState(bWireframe?WireRasterizer:SolidRasterizer);Context->IASetInputLayout(InputLayout);
Context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
FConstants C{};const M4 V=View(Position,F,R,U);const M4 P=Perspective(1.04719755f,static_cast<float>(Width)/std::max(1,Height),0.05f,5000.0f);
M4 Combined{};for(int I=0;I<4;++I)for(int J=0;J<4;++J)for(int K=0;K<4;++K)Combined.M[I][J]+=V.M[I][K]*P.M[K][J];
C.ViewProjection=Transpose(Combined);C.Camera[0]=Position.X;C.Camera[1]=Position.Y;C.Camera[2]=Position.Z;
C.Forward[0]=F.X;C.Forward[1]=F.Y;C.Forward[2]=F.Z;C.LightDirection[0]=-0.5f;C.LightDirection[1]=-0.72f;C.LightDirection[2]=-0.48f;
C.FogStart=260.0f;C.FogEnd=2600.0f;C.Ambient=0.36f;
C.Padding[0]=1.0f;
Context->UpdateSubresource(Constants,0,nullptr,&C,0,0);Context->VSSetConstantBuffers(0,1,&Constants);Context->PSSetConstantBuffers(0,1,&Constants);
Context->VSSetShader(VertexShader,nullptr,0);Context->PSSetShader(PixelShader,nullptr,0);
for(const auto& Pair:StreamingBatches)
{
const FStreamingGpuBatch& L=Pair.second;
if(!bShowLevel[Pair.first.Level]||!L.VertexBuffer||!L.IndexBuffer||!L.IndexCount)continue;
const UINT Stride=sizeof(FGpuVertex),Offset=0;Context->IASetVertexBuffers(0,1,&L.VertexBuffer,&Stride,&Offset);
Context->IASetIndexBuffer(L.IndexBuffer,DXGI_FORMAT_R32_UINT,0);Context->DrawIndexed(L.IndexCount,0,0);
}
// Avoid issuing hundreds of tiny indirect draw calls while the
// initial far batches are still being built. Once the clipmap is
// ready the pooled GPU meshes draw directly as before.
if(bGpuFarEnabled&&ShapeWorld&&ShapeWorld->hasFarWorld())
{
C.Padding[0]=0.01f;
Context->UpdateSubresource(Constants,0,nullptr,&C,0,0);
Context->VSSetConstantBuffers(0,1,&Constants);Context->PSSetConstantBuffers(0,1,&Constants);
for(const auto& Pair:GpuFarTiles)
{
const FGpuFarTile& Tile=Pair.second;
if(!bShowLevel[Pair.first.Level]||!Tile.VertexBuffer||!Tile.IndexBuffer||!Tile.IndirectArgs)continue;
if(!bInitialClipmapReported&&Pair.first.Level>=World->FullResClipLevels)continue;
if(!IsRenderedTileReady(Pair.first))continue;
const UINT Stride=32,Offset=0;
Context->IASetVertexBuffers(0,1,&Tile.VertexBuffer,&Stride,&Offset);
Context->IASetIndexBuffer(Tile.IndexBuffer,DXGI_FORMAT_R32_UINT,0);
Context->DrawIndexedInstancedIndirect(Tile.IndirectArgs,Tile.IndirectArgsByteOffset);
if(Tile.ConnectorVertexBuffer&&Tile.ConnectorIndexBuffer)
{
Context->IASetVertexBuffers(0,1,&Tile.ConnectorVertexBuffer,&Stride,&Offset);
Context->IASetIndexBuffer(Tile.ConnectorIndexBuffer,DXGI_FORMAT_R32_UINT,0);
Context->DrawIndexedInstancedIndirect(Tile.IndirectArgs,
Tile.IndirectArgsByteOffset+5u*sizeof(uint32));
}
}
}
CaptureRenderedFrame();
const auto BeforePresent=std::chrono::steady_clock::now();
const UINT PresentSyncInterval=1u;
const auto PresentCallStart=std::chrono::steady_clock::now();
SwapChain->Present(PresentSyncInterval,0);
const auto PresentCallEnd=std::chrono::steady_clock::now();
UpdateTitle();
const auto DrawEnd=std::chrono::steady_clock::now();
const double CpuPumpMs=std::chrono::duration<double,std::milli>(CpuPumpEnd-DrawStart).count();
const double GpuPumpMs=std::chrono::duration<double,std::milli>(GpuPumpEnd-CpuPumpEnd).count();
const double PresentCallMs=std::chrono::duration<double,std::milli>(PresentCallEnd-PresentCallStart).count();
const double TitleMs=std::chrono::duration<double,std::milli>(DrawEnd-PresentCallEnd).count();
const double RenderPresentMs=PresentCallMs+TitleMs;
if(InterDrawGapMs>50.0||CpuPumpMs>50.0||GpuPumpMs>50.0||RenderPresentMs>50.0)
std::printf("[LongViewerFrame] at_ms=%.3f inter_draw_gap_ms=%.3f cpu_pump_ms=%.3f gpu_pump_ms=%.3f pre_present_ms=%.3f present_sync=%u present_call_ms=%.3f title_ms=%.3f\n",
std::chrono::duration<double,std::milli>(DrawStart-ColdProcessStart).count(),
InterDrawGapMs,CpuPumpMs,GpuPumpMs,
std::chrono::duration<double,std::milli>(BeforePresent-GpuPumpEnd).count(),
PresentSyncInterval,PresentCallMs,TitleMs);
LastDrawEndAt=DrawEnd;
}
};
FApp* GApp=nullptr;
LRESULT CALLBACK WindowProc(HWND H,UINT Message,WPARAM W,LPARAM L)
{
if(!GApp)return DefWindowProc(H,Message,W,L);
switch(Message)
{
case WM_SIZE:if(W!=SIZE_MINIMIZED)GApp->Resize(LOWORD(L),HIWORD(L));return 0;
case WM_KEYDOWN:
{
const bool bWasDown=(L&(1ll<<30))!=0;if(W<256)GApp->Keys[W]=true;
if(W==VK_ESCAPE){if(GApp->bCaptured)GApp->Capture(false);else DestroyWindow(H);}
if(!bWasDown&&W=='F')GApp->bWireframe=!GApp->bWireframe;
if(!bWasDown&&W=='T'){GApp->bRoundTunnels=!GApp->bRoundTunnels;GApp->bRebuildPending=true;}
if(!bWasDown&&W=='V'){GApp->bShapeWorld=!GApp->bShapeWorld;GApp->bRebuildPending=true;}
if(!bWasDown&&W=='G'&&GApp->bRoundTunnels)
{
GApp->bRoundTunnelEnhanced=!GApp->bRoundTunnelEnhanced;
GApp->bRebuildPending=true;
std::printf("Round-tunnel comparison: %s wall field.\n",
GApp->bRoundTunnelEnhanced?"detailed/smoothed":"legacy smooth tube");
}
if(!bWasDown&&W=='H')GApp->ToggleFarRenderer();
if(!bWasDown&&(W=='N'||W=='P'))GApp->RequestSeed(W=='N'?1:-1);
if(!bWasDown&&W>='1'&&W<='8'){const int32 I=static_cast<int32>(W-'1');GApp->bShowLevel[I]=!GApp->bShowLevel[I];}
if(!bWasDown&&W=='9')GApp->bShowLevel[8]=!GApp->bShowLevel[8];
if(!bWasDown&&W=='0')for(bool& B:GApp->bShowLevel)B=!B;
return 0;
}
case WM_KEYUP:if(W<256)GApp->Keys[W]=false;return 0;
case WM_RBUTTONDOWN:GApp->Capture(true);return 0;
case WM_RBUTTONUP:GApp->Capture(false);return 0;
case WM_MOUSEMOVE:
if(GApp->bCaptured){POINT C{GApp->Width/2,GApp->Height/2};ClientToScreen(H,&C);POINT P{GET_X_LPARAM(L),GET_Y_LPARAM(L)},Screen=P;ClientToScreen(H,&Screen);const int32 DX=Screen.x-C.x,DY=Screen.y-C.y;if(DX||DY){GApp->Yaw+=DX*0.0035f;GApp->Pitch=std::clamp(GApp->Pitch-DY*0.0035f,-1.55f,1.55f);SetCursorPos(C.x,C.y);}}return 0;
case WM_MOUSEWHEEL:GApp->MoveSpeed=std::clamp(GApp->MoveSpeed*(GET_WHEEL_DELTA_WPARAM(W)>0?1.25f:0.8f),0.25f,1000.0f);return 0;
case WM_DESTROY:if(GApp->Streamer)GApp->Streamer->Stop();PostQuitMessage(0);return 0;
}
return DefWindowProc(H,Message,W,L);
}
std::filesystem::path DefaultDataPath()
{
wchar_t Module[MAX_PATH]{};GetModuleFileNameW(nullptr,Module,MAX_PATH);
const std::filesystem::path Exe(Module);
return Exe.parent_path().parent_path()/L"data"/L"owner_world.json";
}
int RunTileBenchmark(FStandaloneOwnerWorld& World,V3 CameraPosition,int32 Level,
int32 Count,bool bProfile,bool bCompareEvaluators,bool bDensityHash,
VoxelForgeCore::World* CoreWorld)
{
const FVector CameraVoxels(CameraPosition.X*4.0,CameraPosition.Y*4.0,CameraPosition.Z*4.0);
const FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(World,CameraVoxels);
std::vector<FVoxelTileKey> Tiles;Tiles.reserve(static_cast<size_t>(std::max(Count,1)));
if(CoreWorld)
{
const auto CoreTiles=CoreWorld->desiredTiles({CameraVoxels.X,CameraVoxels.Y,CameraVoxels.Z});
for(const auto& Key:CoreTiles)
if(Key.lod==Level&&static_cast<int32>(Tiles.size())<Count)
Tiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
}
else
{
for(const FVoxelTileKey& Tile:Desired.Tiles)
if(Tile.Level==Level&&static_cast<int32>(Tiles.size())<Count)Tiles.push_back(Tile);
}
if(Tiles.empty())
{std::fprintf(stderr,"No LOD %d tiles are in the current desired set.\n",Level);return 4;}
VoxelGenLOD::InitializeConsoleSwitches();
UVoxelMarchingCubesMesher::InitializeConsoleSwitches();
int32 TileCacheWindow=1,TileCacheWindowMinLOD=3,RoomGraphCacheSlots=1;
FParse::Value(FCommandLine::Get(),"voxel.TileCacheWindow=",TileCacheWindow);
FParse::Value(FCommandLine::Get(),"voxel.TileCacheWindowMinLOD=",TileCacheWindowMinLOD);
FParse::Value(FCommandLine::Get(),"voxel.RoomGraphCacheSlots=",RoomGraphCacheSlots);
std::printf("[BenchmarkConfig] tile_cache_window=%d fused_min_lod=%d room_graph_cache_slots=%d generator=%s command='%s'\n",
TileCacheWindow,TileCacheWindowMinLOD,RoomGraphCacheSlots,
CoreWorld&&!bCompareEvaluators?"VoxelForgeCore":"compatibility-diagnostic",
FCommandLine::Get());
VoxelDensityProfile::SetMode(bProfile?VoxelDensityProfile::EMode::Attribution
:VoxelDensityProfile::EMode::Disabled,128);
if(bProfile)VoxelDensityProfile::CalibrateTimer();
VoxelDensityProfile::Reset();
const VoxelDensityProfile::FSnapshot Before=VoxelDensityProfile::SnapshotCurrentThread();
UVoxelMarchingCubesMesher Mesher;
Mesher.SetGenerator(World.Generator.get());Mesher.bGenerateSkirts=World.bGenerateSkirts;
Mesher.SkirtCells=static_cast<float>(World.SkirtCells);Mesher.LODOctaveDrop=World.LODOctaveDrop;
const int32 BandMin=World.StrateContentCutMinLevel<9&&Desired.bHasStrate
?Desired.StrateBottomChunkZ*CHUNK_SIZE:MIN_int32;
const int32 BandMax=World.StrateContentCutMinLevel<9&&Desired.bHasStrate
?(Desired.StrateTopChunkZ+1)*CHUNK_SIZE:MAX_int32;
if(bCompareEvaluators)
{
const bool bOriginalFused=VoxelGenLOD::IsUseFusedEvaluatorEnabled();
uint64 Mismatches=0,ComparedSamples=0,MeshCountMismatches=0;
float MaxAbsoluteDifference=0.0f;
size_t FirstMismatch=SIZE_MAX;
FVoxelTileKey FirstMismatchTile{};
VoxelGenLOD::SetUseFusedEvaluatorEnabled(true);
for(const FVoxelTileKey& Tile:Tiles)
{
const int32 Cells=Level<World.FullResClipLevels?CHUNK_SIZE:FMath::Max(1,World.CoarseTileCells);
const int32 Step=FMath::Max(1,Tile.ExtentVoxels()/Cells);
std::vector<float> FusedDensities,OpStackDensities;
int64 FusedSampleCalls=0,OpStackSampleCalls=0;
FVoxelMeshData FusedMesh=Mesher.GenerateMesh(Tile.OriginVoxels(),Step,Cells,nullptr,
BandMin,BandMax,&FusedSampleCalls,nullptr,nullptr,&FusedDensities);
VoxelGenLOD::SetUseFusedEvaluatorEnabled(false);
FVoxelMeshData OpStackMesh=Mesher.GenerateMesh(Tile.OriginVoxels(),Step,Cells,nullptr,
BandMin,BandMax,&OpStackSampleCalls,nullptr,nullptr,&OpStackDensities);
VoxelGenLOD::SetUseFusedEvaluatorEnabled(true);
if(FusedMesh.Vertices.Num()!=OpStackMesh.Vertices.Num()
|| FusedMesh.Triangles.Num()!=OpStackMesh.Triangles.Num())++MeshCountMismatches;
const size_t SharedSamples=std::min(FusedDensities.size(),OpStackDensities.size());
ComparedSamples+=SharedSamples;
for(size_t I=0;I<SharedSamples;++I)
{
if(std::bit_cast<uint32>(FusedDensities[I])!=std::bit_cast<uint32>(OpStackDensities[I]))
{
if(FirstMismatch==SIZE_MAX){FirstMismatch=I;FirstMismatchTile=Tile;}
++Mismatches;
MaxAbsoluteDifference=std::max(MaxAbsoluteDifference,
std::abs(FusedDensities[I]-OpStackDensities[I]));
}
}
Mismatches+=static_cast<uint64>(std::max(FusedDensities.size(),OpStackDensities.size())-SharedSamples);
}
std::printf("[EvaluatorCompare] LOD=%d tiles=%zu compared_samples=%llu density_mismatches=%llu first_tile=(%d,%d,%d) first_index=%llu max_abs=%.9g mesh_count_mismatch_tiles=%llu original_fused=%d\n",
Level,Tiles.size(),static_cast<unsigned long long>(ComparedSamples),
static_cast<unsigned long long>(Mismatches),
FirstMismatchTile.Coord.X,FirstMismatchTile.Coord.Y,FirstMismatchTile.Coord.Z,
static_cast<unsigned long long>(FirstMismatch),MaxAbsoluteDifference,
static_cast<unsigned long long>(MeshCountMismatches),bOriginalFused?1:0);
VoxelGenLOD::SetUseFusedEvaluatorEnabled(bOriginalFused);
std::fflush(stdout);
return Mismatches==0?0:5;
}
std::vector<double> TileSeconds;TileSeconds.reserve(Tiles.size());
uint64 Samples=0,Vertices=0,Indices=0;
uint64 DensityHash=14695981039346656037ull;
const auto TotalStart=std::chrono::steady_clock::now();
for(const FVoxelTileKey& Tile:Tiles)
{
const auto TileStart=std::chrono::steady_clock::now();
const int32 Cells=Level<World.FullResClipLevels?CHUNK_SIZE:FMath::Max(1,World.CoarseTileCells);
const int32 Step=FMath::Max(1,Tile.ExtentVoxels()/Cells);
int64 TileSamples=0;
std::vector<float> DebugDensitySamples;
uint64 TileVertices=0,TileIndices=0;
if(CoreWorld&&!bCompareEvaluators)
{
VoxelForgeCore::TileGenerationOptions Options;
Options.bandMinZVoxel=BandMin;Options.bandMaxZVoxel=BandMax;
Options.captureDensitySamples=bDensityHash;
std::string CoreError;
auto Mesh=CoreWorld->generateTile(
{{Tile.Coord.X,Tile.Coord.Y,Tile.Coord.Z},Tile.Level},Options,CoreError);
if(!Mesh)
{
std::fprintf(stderr,"[VoxelForgeCore] benchmark tile generation failed: %s\n",CoreError.c_str());
return 8;
}
TileSamples=static_cast<int64>(Mesh->densitySampleCount);
TileVertices=Mesh->vertices.size();TileIndices=Mesh->indices.size();
if(bDensityHash)DebugDensitySamples=std::move(Mesh->debugDensitySamples);
}
else
{
FVoxelMeshData Mesh=Mesher.GenerateMesh(Tile.OriginVoxels(),Step,Cells,nullptr,
BandMin,BandMax,&TileSamples,nullptr,nullptr,
bDensityHash?&DebugDensitySamples:nullptr);
TileVertices=static_cast<uint64>(Mesh.Vertices.Num());
TileIndices=static_cast<uint64>(Mesh.Triangles.Num());
}
Samples+=static_cast<uint64>(FMath::Max<int64>(0,TileSamples));
Vertices+=TileVertices;
Indices+=TileIndices;
if(bDensityHash)
{
for(const float Density:DebugDensitySamples)
{
DensityHash^=std::bit_cast<uint32>(Density);
DensityHash*=1099511628211ull;
}
}
TileSeconds.push_back(std::chrono::duration<double>(
std::chrono::steady_clock::now()-TileStart).count());
}
const double TotalSeconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-TotalStart).count();
const VoxelDensityProfile::FSnapshot After=VoxelDensityProfile::SnapshotCurrentThread();
std::sort(TileSeconds.begin(),TileSeconds.end());
const double Average=TotalSeconds/static_cast<double>(Tiles.size());
std::printf("[TileBenchmark] LOD=%d generated=%zu samples=%.2fM worker_sum=%.3fs avg=%.3fms p50=%.3fms p95=%.3fms vertices=%llu indices=%llu profiling=%s\n",
Level,Tiles.size(),static_cast<double>(Samples)/1.0e6,TotalSeconds,Average*1000.0,
TileSeconds[(TileSeconds.size()-1)*50/100]*1000.0,
TileSeconds[(TileSeconds.size()-1)*95/100]*1000.0,
static_cast<unsigned long long>(Vertices),static_cast<unsigned long long>(Indices),
bProfile?"Attribution":"off");
if(bDensityHash)
{
std::printf("[TileDensityHash] LOD=%d tiles=%zu hash=0x%016llx\n",Level,Tiles.size(),
static_cast<unsigned long long>(DensityHash));
}
if(bProfile)
{
std::printf("[TileProfile] LOD=%d",Level);
for(int32 I=0;I<VoxelDensityProfile::BucketCount;++I)
{
const uint64 CycleDelta=After.Cycles[I]>=Before.Cycles[I]
?After.Cycles[I]-Before.Cycles[I]:0;
const double Ms=static_cast<double>(CycleDelta)
*FPlatformTime::GetSecondsPerCycle64()*1000.0;
if(Ms>0.001)std::printf(" %s=%.3fms",VoxelDensityProfile::BucketName(
static_cast<VoxelDensityProfile::EBucket>(I)),Ms);
}
std::printf("\n");
const auto CounterDelta=[&](VoxelDensityProfile::ECounter Counter)
{
const size_t I=static_cast<size_t>(Counter);
return After.Counters[I]>=Before.Counters[I]
?After.Counters[I]-Before.Counters[I]:0;
};
std::printf("[TileCounters] sdf_builds=%llu graph_tile_builds=%llu graph_core_builds=%llu op_block_builds=%llu\n",
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfCacheBuild)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::RoomGraphBuildGeneratorTile)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::RoomGraphBuildGeneratorTunnelCore)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::OpBlockBuilds)));
std::printf("[SdfRebuildCauses] strate=%llu seed=%llu fingerprint=%llu layout=%llu manager=%llu terrain_ops=%llu fused_policy=%llu tile_policy=%llu tile_identity=%llu bounds_x=%llu bounds_y=%llu tile_window_accepted=%llu tile_window_rejected=%llu\n",
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildStrate)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildSeed)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildFingerprint)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildLayout)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildManagerLifetime)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildTerrainOps)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildFusedPolicy)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildTilePolicy)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildTileIdentity)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildBoundsX)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfRebuildBoundsY)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfTileWindowAccepted)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::SdfTileWindowRejected)));
std::printf("[TilePolicyKeyChanges] origin=%llu step=%llu cells=%llu fingerprint=%llu layout=%llu manager=%llu terrain_ops=%llu fused_path=%llu context=%llu\n",
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyOrigin)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyStep)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyCells)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyFingerprint)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyLayout)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyManager)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyTerrainOps)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyFusedPath)),
static_cast<unsigned long long>(CounterDelta(VoxelDensityProfile::ECounter::TilePolicyKeyContext)));
}
std::fflush(stdout);
return 0;
}
struct FComparePoint
{
double X=0.0,Y=0.0,Z=0.0;
};
struct FCompareBucketHash
{
size_t operator()(const FIntVector& K)const noexcept
{
uint64 H=static_cast<uint32>(K.X)*0x9E3779B185EBCA87ull;
H^=static_cast<uint64>(static_cast<uint32>(K.Y))*0xC2B2AE3D27D4EB4Full;
H^=static_cast<uint64>(static_cast<uint32>(K.Z))*0x165667B19E3779F9ull;
return static_cast<size_t>(H^(H>>32));
}
};
struct FDirectedSurfaceDistance
{
double Sum=0.0,Maximum=0.0;
uint64 Count=0,Unmatched=0;
};
constexpr int32 OwnerBandGrid=64;
constexpr double OwnerBandSpacing=0.75;
constexpr std::array<double,4> OwnerBandMinWavelength={2.0,4.0,8.0,16.0};
constexpr std::array<double,4> OwnerBandMaxWavelength={4.0,8.0,16.0,32.0};
void FFT64(std::array<std::complex<double>,OwnerBandGrid>& Values)
{
for(int32 I=1,J=0;I<OwnerBandGrid;++I)
{
int32 Bit=OwnerBandGrid>>1;
for(;J&Bit;Bit>>=1)J^=Bit;
J^=Bit;
if(I<J)std::swap(Values[I],Values[J]);
}
for(int32 Length=2;Length<=OwnerBandGrid;Length<<=1)
{
const double Angle=-6.2831853071795864769/static_cast<double>(Length);
const std::complex<double> Step(std::cos(Angle),std::sin(Angle));
for(int32 Base=0;Base<OwnerBandGrid;Base+=Length)
{
std::complex<double> W(1.0,0.0);
for(int32 I=0;I<Length/2;++I)
{
const std::complex<double> Even=Values[Base+I];
const std::complex<double> Odd=Values[Base+I+Length/2]*W;
Values[Base+I]=Even+Odd;Values[Base+I+Length/2]=Even-Odd;W*=Step;
}
}
}
}
bool OwnerSurfaceBandRms(const std::array<double,OwnerBandGrid*OwnerBandGrid>& Heights,
const std::array<uint8,OwnerBandGrid*OwnerBandGrid>& Valid,std::array<double,4>& OutRms)
{
size_t ValidCount=0;
double Sums[3][4]{};
for(int32 Y=0;Y<OwnerBandGrid;++Y)for(int32 X=0;X<OwnerBandGrid;++X)
{
const size_t Index=static_cast<size_t>(Y)*OwnerBandGrid+X;
if(!Valid[Index])continue;
++ValidCount;
const double U=(X-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const double V=(Y-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const double Row[3]={1.0,U,V};
for(int32 I=0;I<3;++I)
{
for(int32 J=0;J<3;++J)Sums[I][J]+=Row[I]*Row[J];
Sums[I][3]+=Row[I]*Heights[Index];
}
}
if(ValidCount<static_cast<size_t>(OwnerBandGrid*OwnerBandGrid*9/10))return false;
for(int32 Column=0;Column<3;++Column)
{
int32 Pivot=Column;
for(int32 Row=Column+1;Row<3;++Row)
if(std::abs(Sums[Row][Column])>std::abs(Sums[Pivot][Column]))Pivot=Row;
if(std::abs(Sums[Pivot][Column])<1.0e-10)return false;
if(Pivot!=Column)for(int32 J=Column;J<4;++J)std::swap(Sums[Pivot][J],Sums[Column][J]);
const double Scale=Sums[Column][Column];
for(int32 J=Column;J<4;++J)Sums[Column][J]/=Scale;
for(int32 Row=0;Row<3;++Row)if(Row!=Column)
{
const double Factor=Sums[Row][Column];
for(int32 J=Column;J<4;++J)Sums[Row][J]-=Factor*Sums[Column][J];
}
}
const double Plane[3]={Sums[0][3],Sums[1][3],Sums[2][3]};
std::array<std::array<std::complex<double>,OwnerBandGrid>,OwnerBandGrid> Spectrum{};
double WindowSquareSum=0.0;
for(int32 Y=0;Y<OwnerBandGrid;++Y)
{
const double WY=0.5-0.5*std::cos(6.2831853071795864769*Y/(OwnerBandGrid-1));
for(int32 X=0;X<OwnerBandGrid;++X)
{
const size_t Index=static_cast<size_t>(Y)*OwnerBandGrid+X;
const double WX=0.5-0.5*std::cos(6.2831853071795864769*X/(OwnerBandGrid-1));
const double U=(X-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const double V=(Y-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const double Residual=Valid[Index]?Heights[Index]-(Plane[0]+Plane[1]*U+Plane[2]*V):0.0;
Spectrum[Y][X]=Residual*(WX*WY);
WindowSquareSum+=WX*WX*WY*WY;
}
FFT64(Spectrum[Y]);
}
for(int32 X=0;X<OwnerBandGrid;++X)
{
std::array<std::complex<double>,OwnerBandGrid> Column{};
for(int32 Y=0;Y<OwnerBandGrid;++Y)Column[Y]=Spectrum[Y][X];
FFT64(Column);
for(int32 Y=0;Y<OwnerBandGrid;++Y)Spectrum[Y][X]=Column[Y];
}
std::array<double,4> Power{};
for(int32 Y=0;Y<OwnerBandGrid;++Y)for(int32 X=0;X<OwnerBandGrid;++X)
{
const double FX=std::min(X,OwnerBandGrid-X)
/(static_cast<double>(OwnerBandGrid)*OwnerBandSpacing);
const double FY=std::min(Y,OwnerBandGrid-Y)
/(static_cast<double>(OwnerBandGrid)*OwnerBandSpacing);
const double Frequency=std::sqrt(FX*FX+FY*FY);
if(Frequency<=0.0)continue;
const double Wavelength=1.0/Frequency;
for(size_t Band=0;Band<Power.size();++Band)
if(Wavelength>=OwnerBandMinWavelength[Band]&&Wavelength<OwnerBandMaxWavelength[Band])
Power[Band]+=std::norm(Spectrum[Y][X]);
}
const double ParsevalScale=static_cast<double>(OwnerBandGrid*OwnerBandGrid)*WindowSquareSum;
for(size_t Band=0;Band<OutRms.size();++Band)
OutRms[Band]=std::sqrt(std::max(0.0,Power[Band]/ParsevalScale));
return true;
}
template<class TDensity>
bool SampleOwnerSurfaceHeightPatch(V3 Origin,V3 Normal,V3 TangentU,V3 TangentV,
TDensity&& Density,std::array<double,OwnerBandGrid*OwnerBandGrid>& OutHeights,
std::array<uint8,OwnerBandGrid*OwnerBandGrid>& OutValid)
{
size_t ValidCount=0;
for(int32 Y=0;Y<OwnerBandGrid;++Y)for(int32 X=0;X<OwnerBandGrid;++X)
{
const double DU=(X-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const double DV=(Y-(OwnerBandGrid-1)*0.5)*OwnerBandSpacing;
const V3 Base=Add(Origin,Add(Mul(TangentU,static_cast<float>(DU)),Mul(TangentV,static_cast<float>(DV))));
double T=0.0;bool bConverged=false;
for(int32 Iteration=0;Iteration<7;++Iteration)
{
const V3 P=Add(Base,Mul(Normal,static_cast<float>(T)));
const double D=Density(P);
if(!std::isfinite(D)||std::abs(T)>16.0)break;
// Core density keeps a 0.05-voxel near-zero sign margin. Accepting a
// tighter root tolerance makes every otherwise-good Core patch fail.
if(std::abs(D)<0.06){bConverged=true;break;}
const double DP=Density(Add(Base,Mul(Normal,static_cast<float>(T+0.5))));
const double DM=Density(Add(Base,Mul(Normal,static_cast<float>(T-0.5))));
const double Gradient=DP-DM;
if(!std::isfinite(Gradient)||std::abs(Gradient)<0.25)break;
T-=std::clamp(D/Gradient,-4.0,4.0);
}
const size_t Index=static_cast<size_t>(Y)*OwnerBandGrid+X;
OutHeights[Index]=T;OutValid[Index]=bConverged?1:0;
ValidCount+=bConverged?1u:0u;
}
return ValidCount>=static_cast<size_t>(OwnerBandGrid*OwnerBandGrid*9/10);
}
FDirectedSurfaceDistance DirectedSurfaceDistance(
const std::vector<FComparePoint>& From,const std::vector<FComparePoint>& To,
double BucketWidth=1.0,int32 SearchCells=3)
{
FDirectedSurfaceDistance Result;
if(From.empty()||To.empty()){Result.Unmatched=From.size();return Result;}
std::unordered_map<FIntVector,std::vector<const FComparePoint*>,FCompareBucketHash> Buckets;
Buckets.reserve(To.size());
const auto BucketOf=[=](const FComparePoint& P)
{
return FIntVector(static_cast<int32>(std::floor(P.X/BucketWidth)),
static_cast<int32>(std::floor(P.Y/BucketWidth)),
static_cast<int32>(std::floor(P.Z/BucketWidth)));
};
for(const FComparePoint& P:To)Buckets[BucketOf(P)].push_back(&P);
for(const FComparePoint& P:From)
{
const FIntVector Center=BucketOf(P);
double BestSquared=std::numeric_limits<double>::infinity();
for(int32 Z=-SearchCells;Z<=SearchCells;++Z)
for(int32 Y=-SearchCells;Y<=SearchCells;++Y)
for(int32 X=-SearchCells;X<=SearchCells;++X)
{
const auto It=Buckets.find(Center+FIntVector(X,Y,Z));
if(It==Buckets.end())continue;
for(const FComparePoint* Candidate:It->second)
{
const double DX=P.X-Candidate->X,DY=P.Y-Candidate->Y,DZ=P.Z-Candidate->Z;
BestSquared=std::min(BestSquared,DX*DX+DY*DY+DZ*DZ);
}
}
if(std::isfinite(BestSquared))
{
const double Distance=std::sqrt(BestSquared);
Result.Sum+=Distance;Result.Maximum=std::max(Result.Maximum,Distance);++Result.Count;
}
else ++Result.Unmatched;
}
return Result;
}
int RunOwnerShapeComparison(FStandaloneOwnerWorld& World,VoxelForgeCore::World& Shape,
V3 CameraPosition,float CameraYaw,float CameraPitch,
int32 Workers,int32 LevelFilter,int32 TileLimit,
std::string_view AreaLabel,bool bCheckOwnerReliefBands)
{
if(!Shape.isCompiled())
{std::fprintf(stderr,"Shape comparison requires a compiled core world.\n");return 11;}
if(LevelFilter>=World.FullResClipLevels&&!Shape.hasFarWorld())Shape.buildFarWorld();
const FVector CameraVoxels(CameraPosition.X*4.0,CameraPosition.Y*4.0,CameraPosition.Z*4.0);
Shape.auditViewSurface({CameraVoxels.X,CameraVoxels.Y,CameraVoxels.Z},CameraYaw,CameraPitch);
{
const int32 Offsets[][3]={{0,0,0},{4,0,0},{-4,0,0},{0,4,0},{0,-4,0},{0,0,4},{0,0,-4}};
for(const auto& Offset:Offsets)
{
const float X=static_cast<float>(CameraVoxels.X+Offset[0]);
const float Y=static_cast<float>(CameraVoxels.Y+Offset[1]);
const float Z=static_cast<float>(CameraVoxels.Z+Offset[2]);
float OwnerDensity=0.0f;
OwnerDensity=World.Generator->GetDensityAt(X,Y,Z);
const float ShapeDensity=Shape.densityAt({X,Y,Z});
std::printf("[ShapeProbe] voxels=(%.1f,%.1f,%.1f) owner=%.5f shape=%.5f owner_air=%d shape_air=%d protected_air=%d solid_overlay=%d\n",
X,Y,Z,OwnerDensity,ShapeDensity,OwnerDensity>=0.0f?1:0,ShapeDensity>=0.0f?1:0,
Shape.debugCriticalAirAt({X,Y,Z})?1:0,Shape.debugSolidOverlayAt({X,Y,Z})?1:0);
}
}
std::vector<FVoxelTileKey> CoreDesired;
for(const auto& Key:Shape.desiredTiles({CameraVoxels.X,CameraVoxels.Y,CameraVoxels.Z}))
CoreDesired.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
std::vector<FVoxelTileKey> Tiles;
for(const FVoxelTileKey& Tile:CoreDesired)
if(LevelFilter<0?Tile.Level<World.FullResClipLevels:Tile.Level==LevelFilter)
Tiles.push_back(Tile);
if(TileLimit>0&&Tiles.size()>static_cast<size_t>(TileLimit))
{
constexpr double DegreesToRadians=3.14159265358979323846/180.0;
const double YawRadians=CameraYaw*DegreesToRadians,PitchRadians=CameraPitch*DegreesToRadians;
const V3 ViewForward{static_cast<float>(std::sin(YawRadians)*std::cos(PitchRadians)),
static_cast<float>(std::cos(YawRadians)*std::cos(PitchRadians)),
static_cast<float>(std::sin(PitchRadians))};
const auto ViewScore=[&](const FVoxelTileKey& Tile)
{
const FIntVector O=Tile.OriginVoxels();
const V3 D{static_cast<float>(O.X+Tile.ExtentVoxels()*0.5-CameraVoxels.X),
static_cast<float>(O.Y+Tile.ExtentVoxels()*0.5-CameraVoxels.Y),
static_cast<float>(O.Z+Tile.ExtentVoxels()*0.5-CameraVoxels.Z)};
const double Distance=std::sqrt(Dot(D,D));
// Keep near tiles first while preferring the half-space in front of this view.
return Distance*Distance+32.0*std::max(0.0,Distance-Dot(D,ViewForward));
};
std::sort(Tiles.begin(),Tiles.end(),[&](const FVoxelTileKey& A,const FVoxelTileKey& B)
{
const double AS=ViewScore(A),BS=ViewScore(B);
if(AS!=BS)return AS<BS;
if(A.Coord.X!=B.Coord.X)return A.Coord.X<B.Coord.X;
if(A.Coord.Y!=B.Coord.Y)return A.Coord.Y<B.Coord.Y;
return A.Coord.Z<B.Coord.Z;
});
Tiles.resize(static_cast<size_t>(TileLimit));
}
if(Tiles.empty()){std::fprintf(stderr,"No tiles are available for the requested shape comparison level.\n");return 12;}
struct FTileComparison
{
uint64 Samples=0,Changed=0,MeshMismatch=0;
uint64 OldHash=14695981039346656037ull,NewHash=14695981039346656037ull;
std::vector<FComparePoint> OldSurface,NewSurface;
std::array<double,4> OwnerBandRms{},ShapeBandRms{};
double SurfacePairDistanceVoxels=0.0;
bool bHasOwnerBandPatch=false;
};
std::vector<FTileComparison> Results(Tiles.size());
int32 MinChunkZ=MIN_int32,MaxChunkZ=MAX_int32,TopChunkZ=0,BottomChunkZ=0;
if(World.Settings->bClampViewToStrate&&World.Manager->GetStrateChunkZBounds(
StandaloneWorldMesher::CameraChunk(CameraVoxels).Z,TopChunkZ,BottomChunkZ))
{MinChunkZ=BottomChunkZ*CHUNK_SIZE;MaxChunkZ=(TopChunkZ+1)*CHUNK_SIZE;}
std::atomic<size_t> Next{0};
std::vector<std::thread> Threads;
const int32 ThreadCount=std::clamp(Workers,1,8);
Threads.reserve(ThreadCount);
for(int32 Worker=0;Worker<ThreadCount;++Worker)
{
Threads.emplace_back([&]()
{
UVoxelMarchingCubesMesher Mesher;
Mesher.SetGenerator(World.Generator.get());
Mesher.bGenerateSkirts=World.bGenerateSkirts;
Mesher.SkirtCells=static_cast<float>(World.SkirtCells);
Mesher.LODOctaveDrop=World.LODOctaveDrop;
for(;;)
{
const size_t Index=Next.fetch_add(1,std::memory_order_relaxed);
if(Index>=Tiles.size())break;
const FVoxelTileKey& Tile=Tiles[Index];
const int32 Cells=Tile.Level<World.FullResClipLevels?CHUNK_SIZE:World.CoarseTileCells;
const int32 Step=std::max(1,Tile.ExtentVoxels()/Cells);
VoxelForgeCore::TileGenerationOptions ShapeOptions;
ShapeOptions.bandMinZVoxel=MinChunkZ;ShapeOptions.bandMaxZVoxel=MaxChunkZ;
ShapeOptions.captureDensitySamples=true;
std::string CoreError;
auto NewMesh=Shape.generateTile({{Tile.Coord.X,Tile.Coord.Y,Tile.Coord.Z},Tile.Level},
ShapeOptions,CoreError);
std::vector<float> NewDensities=NewMesh?std::move(NewMesh->debugDensitySamples):std::vector<float>{};
std::vector<float> OldDensities;
FVoxelMeshData OldMesh;
OldMesh=Mesher.GenerateMesh(Tile.OriginVoxels(),Step,Cells,nullptr,
MinChunkZ,MaxChunkZ,nullptr,nullptr,nullptr,&OldDensities);
FTileComparison& R=Results[Index];
const size_t Shared=std::min(NewDensities.size(),OldDensities.size());
R.Samples=Shared;
R.MeshMismatch=std::max(NewDensities.size(),OldDensities.size())-Shared;
for(size_t I=0;I<Shared;++I)
{
if((NewDensities[I]<0.0f)!=(OldDensities[I]<0.0f))++R.Changed;
R.NewHash^=std::bit_cast<uint32>(NewDensities[I]);R.NewHash*=1099511628211ull;
R.OldHash^=std::bit_cast<uint32>(OldDensities[I]);R.OldHash*=1099511628211ull;
}
if(Tile.Level==0&&NewMesh&&OldMesh.NumSurfaceVertices>0
&&NewMesh->groups.surfaceVertexCount>0)
{
const int32 OldSurfaceCount=std::min(OldMesh.NumSurfaceVertices,
OldMesh.Vertices.Num());
const size_t NewSurfaceCount=std::min<size_t>(
NewMesh->groups.surfaceVertexCount,NewMesh->vertices.size());
const FIntVector TileOrigin=Tile.OriginVoxels();
const V3 TileCenter{TileOrigin.X+Tile.ExtentVoxels()*0.5f,
TileOrigin.Y+Tile.ExtentVoxels()*0.5f,
TileOrigin.Z+Tile.ExtentVoxels()*0.5f};
double OwnerCenterDistanceSq=std::numeric_limits<double>::infinity();
double ShapeCenterDistanceSq=std::numeric_limits<double>::infinity();
V3 OwnerPoint{},OwnerNormal{},ShapePoint{},ShapeNormal{};
for(int32 OldIndex=0;OldIndex<OldSurfaceCount;++OldIndex)
{
if(OldIndex>=OldMesh.Normals.Num())continue;
const FVector& OP=OldMesh.Vertices[OldIndex];
const FVector& ON=OldMesh.Normals[OldIndex];
const V3 CandidatePoint{static_cast<float>(OP.X*0.04),
static_cast<float>(OP.Y*0.04),static_cast<float>(OP.Z*0.04)};
const V3 CandidateNormal=Normalize({static_cast<float>(ON.X),
static_cast<float>(ON.Y),static_cast<float>(ON.Z)});
const V3 Delta=Sub(CandidatePoint,TileCenter);
const double DistanceSq=Dot(Delta,Delta);
if(DistanceSq<OwnerCenterDistanceSq)
{
OwnerCenterDistanceSq=DistanceSq;OwnerPoint=CandidatePoint;
OwnerNormal=CandidateNormal;
}
}
if(std::isfinite(OwnerCenterDistanceSq))
{
for(size_t NewIndex=0;NewIndex<NewSurfaceCount;++NewIndex)
{
const auto& NV=NewMesh->vertices[NewIndex];
const V3 CandidatePoint{static_cast<float>(NV.position.x*0.04),
static_cast<float>(NV.position.y*0.04),
static_cast<float>(NV.position.z*0.04)};
const V3 CandidateNormal=Normalize({static_cast<float>(NV.normal.x),
static_cast<float>(NV.normal.y),static_cast<float>(NV.normal.z)});
if(Dot(CandidateNormal,OwnerNormal)<0.5f)continue;
const V3 Delta=Sub(CandidatePoint,OwnerPoint);
const double DistanceSq=Dot(Delta,Delta);
if(DistanceSq<ShapeCenterDistanceSq)
{
ShapeCenterDistanceSq=DistanceSq;ShapePoint=CandidatePoint;
ShapeNormal=CandidateNormal;
}
}
}
if(std::isfinite(OwnerCenterDistanceSq)&&std::isfinite(ShapeCenterDistanceSq)
&&ShapeCenterDistanceSq<=400.0)
{
const auto TangentBasis=[](V3 Normal,V3& TangentU,V3& TangentV)
{
TangentU=Cross(Normal,{0.0f,0.0f,1.0f});
if(Dot(TangentU,TangentU)<1.0e-6f)
TangentU=Cross(Normal,{1.0f,0.0f,0.0f});
TangentU=Normalize(TangentU);
TangentV=Normalize(Cross(Normal,TangentU));
};
const auto FieldNormal=[](V3 Point,V3 Normal,const auto& Density)
{
if(Dot(Normal,Normal)>=0.25f)return Normalize(Normal);
const V3 GX{0.5f,0.0f,0.0f},GY{0.0f,0.5f,0.0f},GZ{0.0f,0.0f,0.5f};
return Normalize({Density(Add(Point,GX))-Density(Sub(Point,GX)),
Density(Add(Point,GY))-Density(Sub(Point,GY)),
Density(Add(Point,GZ))-Density(Sub(Point,GZ))});
};
const auto OwnerDensity=[&](V3 P)
{return World.Generator->GetDensityAt(P.X,P.Y,P.Z);};
const auto ShapeDensity=[&](V3 P)
{return Shape.densityAt({P.X,P.Y,P.Z});};
OwnerNormal=FieldNormal(OwnerPoint,OwnerNormal,OwnerDensity);
ShapeNormal=FieldNormal(ShapePoint,ShapeNormal,ShapeDensity);
V3 OwnerTangentU{},OwnerTangentV{},ShapeTangentU{},ShapeTangentV{};
TangentBasis(OwnerNormal,OwnerTangentU,OwnerTangentV);
TangentBasis(ShapeNormal,ShapeTangentU,ShapeTangentV);
std::array<double,OwnerBandGrid*OwnerBandGrid> OwnerHeights{},ShapeHeights{};
std::array<uint8,OwnerBandGrid*OwnerBandGrid> OwnerValid{},ShapeValid{};
const bool bOwnerPatch=SampleOwnerSurfaceHeightPatch(OwnerPoint,
OwnerNormal,OwnerTangentU,OwnerTangentV,OwnerDensity,
OwnerHeights,OwnerValid);
const bool bShapePatch=SampleOwnerSurfaceHeightPatch(ShapePoint,
ShapeNormal,ShapeTangentU,ShapeTangentV,ShapeDensity,
ShapeHeights,ShapeValid);
if(bOwnerPatch&&bShapePatch
&&OwnerSurfaceBandRms(OwnerHeights,OwnerValid,R.OwnerBandRms)
&&OwnerSurfaceBandRms(ShapeHeights,ShapeValid,R.ShapeBandRms))
{
R.SurfacePairDistanceVoxels=std::sqrt(ShapeCenterDistanceSq);
R.bHasOwnerBandPatch=true;
}
}
}
constexpr size_t VertexStride=4;
if(NewMesh)
{
R.NewSurface.reserve(NewMesh->vertices.size()/VertexStride+1);
for(size_t I=0;I<NewMesh->vertices.size();I+=VertexStride)
{const auto& P=NewMesh->vertices[I].position;R.NewSurface.push_back({P.x*0.01,P.y*0.01,P.z*0.01});}
}
R.OldSurface.reserve(static_cast<size_t>(OldMesh.Vertices.Num())/VertexStride+1);
for(int32 I=0;I<OldMesh.Vertices.Num();I+=static_cast<int32>(VertexStride))
{const FVector& P=OldMesh.Vertices[I];R.OldSurface.push_back({P.X*0.01,P.Y*0.01,P.Z*0.01});}
}
});
}
for(std::thread& Thread:Threads)Thread.join();
uint64 Samples=0,Changed=0,MeshMismatch=0;
uint64 OwnerBandPatches=0;
std::array<double,4> OwnerBandEnergy{},ShapeBandEnergy{};
double SurfacePairDistanceSum=0.0;
uint64 OldHash=14695981039346656037ull,NewHash=14695981039346656037ull;
size_t OldVertexCount=0,NewVertexCount=0;
std::vector<FComparePoint> OldSurface,NewSurface;
for(const FTileComparison& R:Results)
{
Samples+=R.Samples;Changed+=R.Changed;MeshMismatch+=R.MeshMismatch;
if(R.bHasOwnerBandPatch)
{
++OwnerBandPatches;SurfacePairDistanceSum+=R.SurfacePairDistanceVoxels;
for(size_t Band=0;Band<4;++Band)
{
OwnerBandEnergy[Band]+=R.OwnerBandRms[Band]*R.OwnerBandRms[Band];
ShapeBandEnergy[Band]+=R.ShapeBandRms[Band]*R.ShapeBandRms[Band];
}
}
OldHash^=R.OldHash;OldHash*=1099511628211ull;
NewHash^=R.NewHash;NewHash*=1099511628211ull;
OldVertexCount+=R.OldSurface.size();NewVertexCount+=R.NewSurface.size();
}
OldSurface.reserve(OldVertexCount);NewSurface.reserve(NewVertexCount);
for(FTileComparison& R:Results)
{
OldSurface.insert(OldSurface.end(),R.OldSurface.begin(),R.OldSurface.end());
NewSurface.insert(NewSurface.end(),R.NewSurface.begin(),R.NewSurface.end());
}
const FDirectedSurfaceDistance OldToNew=DirectedSurfaceDistance(OldSurface,NewSurface,1.0,3);
const FDirectedSurfaceDistance NewToOld=DirectedSurfaceDistance(NewSurface,OldSurface,1.0,3);
const uint64 DistanceSamples=OldToNew.Count+NewToOld.Count;
const double MeanDistance=DistanceSamples
?(OldToNew.Sum+NewToOld.Sum)/static_cast<double>(DistanceSamples):0.0;
std::printf("[OwnerShapeCompare] tiles=%zu fullres_levels=%d level_filter=%d lattice_samples=%llu changed_signs=%llu changed_share=%.6f%% old_hash=0x%016llx shape_hash=0x%016llx mesh_sample_mismatch=%llu old_surface_samples=%zu shape_surface_samples=%zu symmetric_vertex_mean_m=%.4f symmetric_vertex_max_m=%.4f unmatched_surface_samples=%llu vertex_stride=4 workers=%d\n",
Tiles.size(),World.FullResClipLevels,LevelFilter,static_cast<unsigned long long>(Samples),
static_cast<unsigned long long>(Changed),Samples?100.0*Changed/Samples:0.0,
static_cast<unsigned long long>(OldHash),static_cast<unsigned long long>(NewHash),
static_cast<unsigned long long>(MeshMismatch),OldSurface.size(),NewSurface.size(),
MeanDistance,std::max(OldToNew.Maximum,NewToOld.Maximum),
static_cast<unsigned long long>(OldToNew.Unmatched+NewToOld.Unmatched),ThreadCount);
const std::array<const char*,4> BandNames={"2-4","4-8","8-16","16-32"};
const std::array<double,4> BandMinimumRatio={0.0,0.75,0.75,0.65};
bool bReliefBandsPass=OwnerBandPatches>0;
std::printf("[OwnerReliefBandCompare] area=%.*s paired_surface_patches=%llu mean_surface_pair_distance=%.3f_vox grid=%dx%d spacing=%.2f_vox bands_rms_vox=",
static_cast<int>(AreaLabel.size()),AreaLabel.data(),
static_cast<unsigned long long>(OwnerBandPatches),OwnerBandPatches
?SurfacePairDistanceSum/static_cast<double>(OwnerBandPatches):0.0,
OwnerBandGrid,OwnerBandGrid,OwnerBandSpacing);
for(size_t Band=0;Band<4;++Band)
{
const double OwnerRms=OwnerBandPatches
?std::sqrt(OwnerBandEnergy[Band]/static_cast<double>(OwnerBandPatches)):0.0;
const double ShapeRms=OwnerBandPatches
?std::sqrt(ShapeBandEnergy[Band]/static_cast<double>(OwnerBandPatches)):0.0;
const double Ratio=OwnerRms>1.0e-5?ShapeRms/OwnerRms:0.0;
std::printf("%s(owner=%.4f,shape=%.4f,ratio=%.3f)%s",BandNames[Band],
OwnerRms,ShapeRms,Ratio,Band<3?" ":"\n");
if(Band>0&&OwnerRms>=0.025&&Ratio<BandMinimumRatio[Band])bReliefBandsPass=false;
}
std::printf("[OwnerReliefBandAudit] minimum_ratio_4-8=0.750 minimum_ratio_8-16=0.750 minimum_ratio_16-32=0.650 evaluated_patches=%llu status=%s%s\n",
static_cast<unsigned long long>(OwnerBandPatches),bReliefBandsPass?"PASS":"FAIL",
bCheckOwnerReliefBands?" (gate enabled)":" (measurement only)");
std::fflush(stdout);
return Samples>0&&MeshMismatch==0&&(!bCheckOwnerReliefBands||bReliefBandsPass)?0:13;
}
int RunRoundWallComparison(FStandaloneOwnerWorld& World,V3 CameraPosition,int32 TileCount)
{
const FVector CameraVoxels(CameraPosition.X*4.0,CameraPosition.Y*4.0,CameraPosition.Z*4.0);
const FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(World,CameraVoxels);
std::vector<FVoxelTileKey> Tiles;Tiles.reserve(static_cast<size_t>(TileCount));
for(const FVoxelTileKey& Tile:Desired.Tiles)
if(Tile.Level==0&&static_cast<int32>(Tiles.size())<TileCount)Tiles.push_back(Tile);
if(Tiles.empty()){std::fprintf(stderr,"No LOD0 tiles are available for the round-tunnel comparison.\n");return 9;}
struct FComparisonTile
{
std::vector<float> Densities;
std::vector<FComparePoint> Surface;
};
std::vector<FComparisonTile> Legacy(Tiles.size());
std::vector<FComparisonTile> Detailed(Tiles.size());
UVoxelMarchingCubesMesher Mesher;
Mesher.SetGenerator(World.Generator.get());Mesher.bGenerateSkirts=World.bGenerateSkirts;
Mesher.SkirtCells=static_cast<float>(World.SkirtCells);Mesher.LODOctaveDrop=World.LODOctaveDrop;
int32 MinChunkZ=MIN_int32,MaxChunkZ=MAX_int32,TopChunkZ=0,BottomChunkZ=0;
if(World.Settings->bClampViewToStrate&&World.Manager->GetStrateChunkZBounds(
StandaloneWorldMesher::CameraChunk(CameraVoxels).Z,TopChunkZ,BottomChunkZ))
{
MinChunkZ=BottomChunkZ*CHUNK_SIZE;
MaxChunkZ=(TopChunkZ+1)*CHUNK_SIZE;
}
uint64 TotalSamples=0,ChangedSigns=0;
uint64 LegacyHash=14695981039346656037ull,DetailedHash=14695981039346656037ull;
const bool PreviousRoundTunnels=World.Generator->bStandaloneResearchRoundTunnels;
const bool PreviousEnhancedWalls=World.Generator->bStandaloneResearchEnhancedWalls;
const auto Evaluate=[&](bool bEnhanced,std::vector<FComparisonTile>& Out)
{
World.Generator->bStandaloneResearchRoundTunnels=true;
World.Generator->bStandaloneResearchEnhancedWalls=bEnhanced;
for(size_t I=0;I<Tiles.size();++I)
{
const FVoxelTileKey& Tile=Tiles[I];
const int32 Step=1,Cells=CHUNK_SIZE;
FVoxelMeshData Mesh=Mesher.GenerateMesh(Tile.OriginVoxels(),Step,Cells,nullptr,
MinChunkZ,MaxChunkZ,nullptr,nullptr,nullptr,&Out[I].Densities);
Out[I].Surface.reserve(static_cast<size_t>(Mesh.Vertices.Num()));
for(const FVector& P:Mesh.Vertices)
Out[I].Surface.push_back({P.X*0.01,P.Y*0.01,P.Z*0.01});
}
};
Evaluate(false,Legacy);
Evaluate(true,Detailed);
World.Generator->bStandaloneResearchRoundTunnels=PreviousRoundTunnels;
World.Generator->bStandaloneResearchEnhancedWalls=PreviousEnhancedWalls;
FDirectedSurfaceDistance LegacyToDetailed,DetailedToLegacy;
std::vector<FComparePoint> AllLegacySurface,AllDetailedSurface;
for(size_t TileIndex=0;TileIndex<Tiles.size();++TileIndex)
{
const auto& A=Legacy[TileIndex];const auto& B=Detailed[TileIndex];
const size_t Shared=std::min(A.Densities.size(),B.Densities.size());
TotalSamples+=Shared;
for(size_t I=0;I<Shared;++I)
{
if((A.Densities[I]<0.0f)!=(B.Densities[I]<0.0f))++ChangedSigns;
LegacyHash^=std::bit_cast<uint32>(A.Densities[I]);LegacyHash*=1099511628211ull;
DetailedHash^=std::bit_cast<uint32>(B.Densities[I]);DetailedHash*=1099511628211ull;
}
AllLegacySurface.insert(AllLegacySurface.end(),A.Surface.begin(),A.Surface.end());
AllDetailedSurface.insert(AllDetailedSurface.end(),B.Surface.begin(),B.Surface.end());
}
LegacyToDetailed=DirectedSurfaceDistance(AllLegacySurface,AllDetailedSurface);
DetailedToLegacy=DirectedSurfaceDistance(AllDetailedSurface,AllLegacySurface);
const uint64 DistanceSamples=LegacyToDetailed.Count+DetailedToLegacy.Count;
const double MeanDistance=DistanceSamples>0
?(LegacyToDetailed.Sum+DetailedToLegacy.Sum)/static_cast<double>(DistanceSamples):0.0;
const double Hausdorff=std::max(LegacyToDetailed.Maximum,DetailedToLegacy.Maximum);
std::printf("[RoundTunnelCompare] tiles=%zu lattice_samples=%llu changed_signs=%llu changed_share=%.6f%% legacy_density_hash=0x%016llx detailed_density_hash=0x%016llx old_vertices=%zu new_vertices=%zu symmetric_vertex_mean_m=%.4f symmetric_vertex_max_m=%.4f unmatched_vertices=%llu\n",
Tiles.size(),static_cast<unsigned long long>(TotalSamples),
static_cast<unsigned long long>(ChangedSigns),TotalSamples?100.0*ChangedSigns/TotalSamples:0.0,
static_cast<unsigned long long>(LegacyHash),static_cast<unsigned long long>(DetailedHash),
AllLegacySurface.size(),AllDetailedSurface.size(),MeanDistance,Hausdorff,
static_cast<unsigned long long>(LegacyToDetailed.Unmatched+DetailedToLegacy.Unmatched));
return TotalSamples>0&&LegacyToDetailed.Unmatched+DetailedToLegacy.Unmatched==0?0:10;
}
void HashWord(uint64& Hash,uint64 Word,int32 Bytes=8)
{
for(int32 I=0;I<Bytes;++I)
{
Hash^=static_cast<uint8>(Word>>(I*8));
Hash*=1099511628211ull;
}
}
struct FHashedTile
{
FVoxelTileKey Key;
uint64 Hash=14695981039346656037ull;
};
bool TileKeyLessForHash(const FVoxelTileKey& A,const FVoxelTileKey& B)
{
if(A.Level!=B.Level)return A.Level<B.Level;
if(A.Coord.Z!=B.Coord.Z)return A.Coord.Z<B.Coord.Z;
if(A.Coord.Y!=B.Coord.Y)return A.Coord.Y<B.Coord.Y;
return A.Coord.X<B.Coord.X;
}
uint64 HashTileRows(std::vector<FHashedTile>& Rows)
{
std::sort(Rows.begin(),Rows.end(),[](const FHashedTile& A,const FHashedTile& B)
{return TileKeyLessForHash(A.Key,B.Key);});
uint64 Hash=14695981039346656037ull;
for(const FHashedTile& Row:Rows)
{
HashWord(Hash,static_cast<uint32>(Row.Key.Level),4);
HashWord(Hash,static_cast<uint32>(Row.Key.Coord.X),4);
HashWord(Hash,static_cast<uint32>(Row.Key.Coord.Y),4);
HashWord(Hash,static_cast<uint32>(Row.Key.Coord.Z),4);
HashWord(Hash,Row.Hash);
}
return Hash;
}
int RunPipelinedStreamingBenchmark(std::shared_ptr<FStandaloneOwnerWorld> OwnerWorld,
const VoxelForgeCore::ResolvedWorldSnapshot& CoreSnapshot,
const FVector& CameraPositionVoxels,int32 WorkerCount,int32 MaxLevel,
VoxelForgeCore::DetailVariant DetailVariant,const VoxelForgeCore::JobScheduler& Scheduler,
bool bHashDensity,bool bSkipUvAndColors,bool bSkipMaterialGroups,bool bSkipUV,bool bSkipColors,
std::chrono::steady_clock::time_point ColdStart)
{
using Clock=std::chrono::steady_clock;
FStandaloneOwnerWorld& World=*OwnerWorld;
const bool bRoundTunnels=World.Generator->bStandaloneResearchRoundTunnels;
const bool bEnhancedTunnelWalls=World.Generator->bStandaloneResearchEnhancedWalls;
VoxelForgeCore::World Shape(CoreSnapshot);
FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(World,CameraPositionVoxels);
const auto CoreTiles=Shape.desiredTiles(
{CameraPositionVoxels.X,CameraPositionVoxels.Y,CameraPositionVoxels.Z});
Desired.Tiles.clear();Desired.Tiles.reserve(CoreTiles.size());
for(const auto& Key:CoreTiles)
Desired.Tiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
if(MaxLevel>=0)
Desired.Tiles.erase(std::remove_if(Desired.Tiles.begin(),Desired.Tiles.end(),
[&](const FVoxelTileKey& Tile){return Tile.Level>MaxLevel;}),Desired.Tiles.end());
FIntVector FineMin(INT32_MAX,INT32_MAX,INT32_MAX),FineMax(INT32_MIN,INT32_MIN,INT32_MIN);
FIntVector ClipMin(INT32_MAX,INT32_MAX,INT32_MAX),ClipMax(INT32_MIN,INT32_MIN,INT32_MIN);
for(const FVoxelTileKey& Tile:Desired.Tiles)
{
const FIntVector Origin=Tile.OriginVoxels();const int32 Extent=Tile.ExtentVoxels();
ClipMin.X=std::min(ClipMin.X,Origin.X);ClipMin.Y=std::min(ClipMin.Y,Origin.Y);ClipMin.Z=std::min(ClipMin.Z,Origin.Z);
ClipMax.X=std::max(ClipMax.X,Origin.X+Extent);ClipMax.Y=std::max(ClipMax.Y,Origin.Y+Extent);ClipMax.Z=std::max(ClipMax.Z,Origin.Z+Extent);
if(Tile.Level<World.FullResClipLevels)
{
FineMin.X=std::min(FineMin.X,Origin.X);FineMin.Y=std::min(FineMin.Y,Origin.Y);FineMin.Z=std::min(FineMin.Z,Origin.Z);
FineMax.X=std::max(FineMax.X,Origin.X+Extent);FineMax.Y=std::max(FineMax.Y,Origin.Y+Extent);FineMax.Z=std::max(FineMax.Z,Origin.Z+Extent);
}
}
if(FineMin.X==INT32_MAX||ClipMin.X==INT32_MAX)
{std::fprintf(stderr,"[StreamPipeline] no desired detail or clipmap tiles.\n");return 7;}
const FIntVector CenterChunk=Desired.CenterChunk;
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> Neighborhood;
Neighborhood.reserve(32);
for(const FVoxelTileKey& Tile:Desired.Tiles)
if(Tile.Level==0&&std::abs(Tile.Coord.X-CenterChunk.X)<=1
&&std::abs(Tile.Coord.Y-CenterChunk.Y)<=1&&std::abs(Tile.Coord.Z-CenterChunk.Z)<=1)
Neighborhood.insert(Tile);
if(Neighborhood.size()!=27)
{std::fprintf(stderr,"[StreamPipeline] expected 27 player-neighborhood tiles, found %zu.\n",Neighborhood.size());return 7;}
// The initial desired set now owns all clipmap metadata needed by this Core-only run.
// Release the separate compatibility-world generation graph before compiling Core.
World.Generator.reset();
World.Manager.reset();
World.DefinitionStorage.clear();
World.BiomeStorage.clear();
World.OperationStorage.clear();
World.DensitySamples.clear();
std::string BuildError;
const bool bIncludeFarWorld=MaxLevel<0||MaxLevel>=World.FullResClipLevels;
const auto ShapeBuildStart=Clock::now();
VoxelForgeCore::ShapeBuildRequest ShapeRequest;
ShapeRequest.minVoxel={FineMin.X,FineMin.Y,FineMin.Z};
ShapeRequest.maxVoxel={FineMax.X,FineMax.Y,FineMax.Z};
ShapeRequest.clipMinVoxel={ClipMin.X,ClipMin.Y,ClipMin.Z};
ShapeRequest.clipMaxVoxel={ClipMax.X,ClipMax.Y,ClipMax.Z};
ShapeRequest.workerLimit=static_cast<uint32>(std::clamp(WorkerCount,1,8));
ShapeRequest.detail=DetailVariant;ShapeRequest.includeFarWorld=bIncludeFarWorld;
ShapeRequest.roundTunnels=bRoundTunnels;
ShapeRequest.enhancedTunnelWalls=bEnhancedTunnelWalls;
if(!Shape.compile(ShapeRequest,Scheduler,BuildError))
{std::fprintf(stderr,"[StreamPipeline] full shape build failed: %s\n",BuildError.c_str());return 2;}
const auto ShapeReady=Clock::now();
const double ShapeSeconds=std::chrono::duration<double>(ShapeReady-ShapeBuildStart).count();
FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape);
const auto StreamStart=Clock::now();
const FStandaloneStreamingUpdate Update=Streamer.StartWithDesired(Desired);
if(Update.DesiredTiles!=static_cast<int32>(Desired.Tiles.size()))
{
Streamer.Stop();
std::fprintf(stderr,"[StreamPipeline] expected %zu tiles but queued %d.\n",
Desired.Tiles.size(),Update.DesiredTiles);return 7;
}
std::vector<FHashedTile> DensityRows,MeshRows,PayloadRows,TopologyRows;
int32 Finished=0,NeighborhoodFinished=0,FullDetailFinished=0;
int32 FullDetailExpected=0;
for(const FVoxelTileKey& Tile:Desired.Tiles)
if(Tile.Level<World.FullResClipLevels)++FullDetailExpected;
Clock::time_point NeighborhoodReady{},FullDetailReady{},WholeViewReady{};
bool bNeighborhoodReported=false,bFullDetailReported=false;
while(Finished<Update.DesiredTiles)
{
std::vector<FStandaloneCpuTile> Ready=Streamer.TakeReady();
if(Ready.empty()){std::this_thread::sleep_for(std::chrono::milliseconds(1));continue;}
for(const FStandaloneCpuTile& Tile:Ready)
{
++Finished;
WholeViewReady=std::max(WholeViewReady,Tile.CompletedAt);
if(Neighborhood.contains(Tile.Key))
{
++NeighborhoodFinished;
NeighborhoodReady=std::max(NeighborhoodReady,Tile.CompletedAt);
}
if(Tile.Key.Level<World.FullResClipLevels)
{
++FullDetailFinished;
FullDetailReady=std::max(FullDetailReady,Tile.CompletedAt);
}
if(bHashDensity)
{
if(Tile.bHasDensityHash)DensityRows.push_back({Tile.Key,Tile.DensityHash});
if(Tile.bHasMeshHash)MeshRows.push_back({Tile.Key,Tile.MeshHash});
if(Tile.bHasPayloadHash)PayloadRows.push_back({Tile.Key,Tile.PayloadHash});
if(Tile.bHasTopologyHash)TopologyRows.push_back({Tile.Key,Tile.TopologyHash});
}
}
if(!bNeighborhoodReported&&NeighborhoodFinished==static_cast<int32>(Neighborhood.size()))
{
std::printf("[PipelineMilestone] neighborhood_ready=%.3fs generated=%d/27\n",
std::chrono::duration<double>(NeighborhoodReady-ColdStart).count(),NeighborhoodFinished);
bNeighborhoodReported=true;
}
if(!bFullDetailReported&&FullDetailFinished==FullDetailExpected)
{
std::printf("[PipelineMilestone] full_detail_ready=%.3fs generated=%d/%d\n",
std::chrono::duration<double>(FullDetailReady-ColdStart).count(),
FullDetailFinished,FullDetailExpected);
bFullDetailReported=true;
}
}
Streamer.Stop();
const double NeighborhoodSeconds=std::chrono::duration<double>(NeighborhoodReady-ColdStart).count();
const double NeighborhoodMeshSeconds=std::chrono::duration<double>(NeighborhoodReady-ShapeReady).count();
const double FullDetailSeconds=std::chrono::duration<double>(FullDetailReady-ColdStart).count();
const double WholeViewSeconds=std::chrono::duration<double>(WholeViewReady-ColdStart).count();
const double StreamSeconds=std::chrono::duration<double>(WholeViewReady-StreamStart).count();
std::printf("[StreamPipeline] workers=%d shape=%.3fs neighborhood_mesh=%.3fs neighborhood_ready=%.3fs full_detail_ready=%.3fs whole_view_ready=%.3fs neighborhood_tiles=%d/27 full_detail_tiles=%d/%d whole_tiles=%d/%zu stream_wall=%.3fs cache_hits=0 full_payload=1\n",
WorkerCount,ShapeSeconds,NeighborhoodMeshSeconds,NeighborhoodSeconds,
FullDetailSeconds,WholeViewSeconds,NeighborhoodFinished,
FullDetailFinished,FullDetailExpected,Finished,Desired.Tiles.size(),StreamSeconds);
bool bHashesPassing=true;
if(bHashDensity)
{
bHashesPassing=DensityRows.size()==Desired.Tiles.size()
&&MeshRows.size()==Desired.Tiles.size()
&&PayloadRows.size()==Desired.Tiles.size()
&&TopologyRows.size()==Desired.Tiles.size();
std::vector<FHashedTile> FullDensity,FullMesh,FullPayload,FullTopology;
for(const FHashedTile& Row:DensityRows)if(Row.Key.Level<World.FullResClipLevels)FullDensity.push_back(Row);
for(const FHashedTile& Row:MeshRows)if(Row.Key.Level<World.FullResClipLevels)FullMesh.push_back(Row);
for(const FHashedTile& Row:PayloadRows)if(Row.Key.Level<World.FullResClipLevels)FullPayload.push_back(Row);
for(const FHashedTile& Row:TopologyRows)if(Row.Key.Level<World.FullResClipLevels)FullTopology.push_back(Row);
std::printf("[PipelineFullDetailHash] tiles=%d density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx\n",
FullDetailExpected,static_cast<unsigned long long>(HashTileRows(FullDensity)),
static_cast<unsigned long long>(HashTileRows(FullMesh)),
static_cast<unsigned long long>(HashTileRows(FullPayload)),
static_cast<unsigned long long>(HashTileRows(FullTopology)));
std::printf("[PipelineWholeViewHash] tiles=%zu density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx\n",
Desired.Tiles.size(),static_cast<unsigned long long>(HashTileRows(DensityRows)),
static_cast<unsigned long long>(HashTileRows(MeshRows)),
static_cast<unsigned long long>(HashTileRows(PayloadRows)),
static_cast<unsigned long long>(HashTileRows(TopologyRows)));
}
return NeighborhoodFinished==static_cast<int32>(Neighborhood.size())
&&FullDetailFinished==FullDetailExpected&&Finished==Update.DesiredTiles&&bHashesPassing?0:6;
}
int RunStreamingBenchmark(FStandaloneOwnerWorld& World,VoxelForgeCore::World* CoreWorld,
const FVector& CameraPositionVoxels,
int32 WorkerCount,int32 MaxLevel,bool bRoundTunnels,
bool bEnhancedWalls,const FStandaloneMeshCache* Cache,
bool bHashDensity,bool bSkipUvAndColors,bool bSkipMaterialGroups,
bool bSkipUV,bool bSkipColors,
bool bShardAudit,bool bFarSurvivalAudit,bool bFarAuditBadShell,
float CameraYaw,float CameraPitch,
const std::string& BakeCachePath,
const FStandaloneMeshCacheMetadata& CacheMetadata)
{
FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(World,CameraPositionVoxels);
if(CoreWorld)
{
const auto CoreTiles=CoreWorld->desiredTiles(
{CameraPositionVoxels.X,CameraPositionVoxels.Y,CameraPositionVoxels.Z});
Desired.Tiles.clear();Desired.Tiles.reserve(CoreTiles.size());
for(const auto& Key:CoreTiles)
Desired.Tiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
}
if(MaxLevel>=0)
Desired.Tiles.erase(std::remove_if(Desired.Tiles.begin(),Desired.Tiles.end(),
[&](const FVoxelTileKey& Tile){return Tile.Level>MaxLevel;}),Desired.Tiles.end());
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> DesiredTileSet;
DesiredTileSet.reserve(Desired.Tiles.size()*2+1);
for(const FVoxelTileKey& Tile:Desired.Tiles)DesiredTileSet.insert(Tile);
if(Desired.Tiles.size()>1000000)
{
std::fprintf(stderr,"Stream benchmark rejected an unsafe desired set of %zu tiles.\n",
Desired.Tiles.size());
return 7;
}
const int32 FullDetailExpected=static_cast<int32>(std::count_if(
Desired.Tiles.begin(),Desired.Tiles.end(),[&](const FVoxelTileKey& Tile)
{return Tile.Level<World.FullResClipLevels;}));
std::unique_ptr<FFarSurvivalAudit> FarAudit;
if(bFarSurvivalAudit)
{
if(!CoreWorld||!CoreWorld->hasFarWorld())
{std::fprintf(stderr,"Far survival audit requires a compiled core world with far-parent data.\n");return 15;}
FarAudit=std::make_unique<FFarSurvivalAudit>(World,*CoreWorld,Desired.Tiles,bFarAuditBadShell);
}
std::array<std::vector<FHashedTile>,MaxLevels+1> HashRows;
std::array<std::vector<FHashedTile>,MaxLevels+1> MeshHashRows;
std::array<std::vector<FHashedTile>,MaxLevels+1> PayloadHashRows;
std::array<std::vector<FHashedTile>,MaxLevels+1> TopologyHashRows;
std::array<uint64,MaxLevels+1> SamplesByLevel{};
std::array<uint64,MaxLevels+1> VerticesByLevel{};
std::array<uint64,MaxLevels+1> IndicesByLevel{};
std::array<uint64,MaxLevels+1> TilesByLevel{};
std::array<double,MaxLevels+1> WorkerSecondsByLevel{};
std::array<double,MaxLevels+1> FirstCompletionByLevel{};
std::array<double,MaxLevels+1> LastCompletionByLevel{};
std::array<uint64,MaxLevels+1> OutputBytesByLevel{};
std::array<uint64,MaxLevels+1> MeshPayloadAllocatedBytesByLevel{};
FirstCompletionByLevel.fill(std::numeric_limits<double>::infinity());
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> PlayerNeighborhoodTiles;
for(const FVoxelTileKey& Tile:Desired.Tiles)
if(Tile.Level==0&&std::abs(Tile.Coord.X-Desired.CenterChunk.X)<=1
&&std::abs(Tile.Coord.Y-Desired.CenterChunk.Y)<=1
&&std::abs(Tile.Coord.Z-Desired.CenterChunk.Z)<=1)
PlayerNeighborhoodTiles.insert(Tile);
std::unordered_set<FVoxelTileKey,FStandaloneTileKeyHash> PlayerNeighborhoodReady;
auto PlayerNeighborhoodCompleted=std::chrono::steady_clock::time_point{};
std::vector<FStandaloneCpuTile> CacheTiles;
if(!BakeCachePath.empty())CacheTiles.reserve(Desired.Tiles.size());
if(CoreWorld&&!FarAudit)
{
// Tile keys and band limits are already captured in Desired. Core owns field and
// mesh generation, so discard the unused compatibility generator before streaming.
World.Generator.reset();
World.Manager.reset();
World.DefinitionStorage.clear();
World.BiomeStorage.clear();
World.OperationStorage.clear();
World.DensitySamples.clear();
}
const auto Start=std::chrono::steady_clock::now();
FStandaloneStreamingGenerator Streamer(World,WorkerCount,
bHashDensity||!BakeCachePath.empty(),Cache,MaxLevel,
bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,CoreWorld);
const FStandaloneStreamingUpdate Update=CoreWorld
?Streamer.StartWithDesired(Desired):Streamer.Start(CameraPositionVoxels);
const double LOD0Width=static_cast<double>(2*World.ClipRadius+2)
*CHUNK_SIZE*VOXEL_SIZE/100.0;
std::printf("[StreamBenchmarkConfig] clip_radius=%d lod0_cube=%.0fm voxel=25cm fullres_levels=%d max_level_filter=%d workers=%d full_detail_tiles=%d desired_tiles=%d variant=%s uv=%s colors=%s material_groups=%s hash=%s\n",
World.ClipRadius,LOD0Width,World.FullResClipLevels,MaxLevel<0?World.MaxClipLevel:MaxLevel,
Streamer.GetWorkerCount(),FullDetailExpected,Update.DesiredTiles,
bRoundTunnels?(bEnhancedWalls?"round-detailed":"round-legacy"):"base",
(bSkipUvAndColors||bSkipUV)?"skipped":"full",
(bSkipUvAndColors||bSkipColors)?"skipped":"full",
bSkipMaterialGroups?"skipped":"full",
(bHashDensity||!BakeCachePath.empty())?"on":"off");
std::fflush(stdout);
int32 Finished=0,FullDetailFinished=0;
bool bFullDetailTimeReported=false;
double FullDetailSeconds=0.0;
const int32 DesiredTotal=Update.DesiredTiles;
FMeshSheetAudit MeshSheetStats;
FMeshArtifactAudit MeshArtifactStats;
FCoarsePanelAudit CoarsePanelStats;
uint64 MeshAuditedTiles=0;
while(Finished<DesiredTotal)
{
std::vector<FStandaloneCpuTile> Ready=Streamer.TakeReady();
if(Ready.empty())
{
std::this_thread::sleep_for(std::chrono::milliseconds(1));
continue;
}
for(FStandaloneCpuTile& Tile:Ready)
{
if(FarAudit)FarAudit->AuditTile(Tile);
++Finished;
const int32 Level=Tile.Key.Level;
if(PlayerNeighborhoodTiles.contains(Tile.Key))
{
PlayerNeighborhoodReady.insert(Tile.Key);
if(PlayerNeighborhoodReady.size()==PlayerNeighborhoodTiles.size())
PlayerNeighborhoodCompleted=Tile.CompletedAt;
}
if(Level>=0&&Level<=MaxLevels)
{
SamplesByLevel[Level]+=Tile.DensitySamples;
VerticesByLevel[Level]+=Tile.Vertices.size();
IndicesByLevel[Level]+=Tile.Indices.size();
++TilesByLevel[Level];
WorkerSecondsByLevel[Level]+=Tile.WorkerSeconds;
const double CompletedSeconds=std::chrono::duration<double>(Tile.CompletedAt-Start).count();
FirstCompletionByLevel[Level]=std::min(FirstCompletionByLevel[Level],CompletedSeconds);
LastCompletionByLevel[Level]=std::max(LastCompletionByLevel[Level],CompletedSeconds);
OutputBytesByLevel[Level]+=static_cast<uint64>(Tile.Vertices.capacity())*sizeof(FStandaloneCpuVertex)
+static_cast<uint64>(Tile.Indices.capacity())*sizeof(uint32)
+static_cast<uint64>(Tile.TriangleSkirtFaceMasks.capacity())*sizeof(uint8);
MeshPayloadAllocatedBytesByLevel[Level]+=Tile.MeshPayloadAllocatedBytes;
if(Tile.bHasDensityHash)HashRows[Level].push_back({Tile.Key,Tile.DensityHash});
if(Tile.bHasMeshHash)MeshHashRows[Level].push_back({Tile.Key,Tile.MeshHash});
if(Tile.bHasPayloadHash)PayloadHashRows[Level].push_back({Tile.Key,Tile.PayloadHash});
if(Tile.bHasTopologyHash)TopologyHashRows[Level].push_back({Tile.Key,Tile.TopologyHash});
}
if(Level<World.FullResClipLevels)++FullDetailFinished;
if(bShardAudit&&Level==0)
{
const FMeshSheetAudit TileAudit=AuditThinMeshSheets(Tile,CameraPositionVoxels,
CameraYaw,CameraPitch,
MeshSheetStats.ThinSheets==0
&&MeshSheetStats.SmallComponentsInView
+MeshSheetStats.BoundarySmallComponentsInView<8);
MeshSheetStats.Components+=TileAudit.Components;
MeshSheetStats.SmallComponents+=TileAudit.SmallComponents;
MeshSheetStats.ThinSheets+=TileAudit.ThinSheets;
MeshSheetStats.SmallComponentsInView+=TileAudit.SmallComponentsInView;
MeshSheetStats.BoundarySmallComponentsInView+=TileAudit.BoundarySmallComponentsInView;
MeshSheetStats.TrianglesInThinSheets+=TileAudit.TrianglesInThinSheets;
MeshSheetStats.MinimumThicknessVoxels=std::min(MeshSheetStats.MinimumThicknessVoxels,
TileAudit.MinimumThicknessVoxels);
++MeshAuditedTiles;
}
if(bShardAudit&&Level<=1&&CoreWorld)
{
const FMeshArtifactAudit TileAudit=AuditMeshArtifacts(
Tile,*CoreWorld,std::max(1,World.SkirtCells)*(1<<Level)*0.25,
ComputeVisibleSkirtFaceMask(Tile.Key,DesiredTileSet),
MeshArtifactStats.ExposedSkirtTriangles<8,
MeshArtifactStats.RepeatedOffsetPatches<8);
MeshArtifactStats.Tiles+=TileAudit.Tiles;
MeshArtifactStats.SurfaceVertices+=TileAudit.SurfaceVertices;
MeshArtifactStats.EdgeVertices+=TileAudit.EdgeVertices;
MeshArtifactStats.MidpointVertices+=TileAudit.MidpointVertices;
MeshArtifactStats.SkirtTriangles+=TileAudit.SkirtTriangles;
MeshArtifactStats.HiddenSameLodSkirtTriangles+=TileAudit.HiddenSameLodSkirtTriangles;
MeshArtifactStats.ExposedSkirtTriangles+=TileAudit.ExposedSkirtTriangles;
MeshArtifactStats.ReverseSideSolidSkirtTriangles+=TileAudit.ReverseSideSolidSkirtTriangles;
MeshArtifactStats.RepeatedOffsetPatches+=TileAudit.RepeatedOffsetPatches;
MeshArtifactStats.FieldMismatchPatches+=TileAudit.FieldMismatchPatches;
MeshArtifactStats.NormalMismatchPatches+=TileAudit.NormalMismatchPatches;
MeshArtifactStats.GradientFallbackPatches+=TileAudit.GradientFallbackPatches;
MeshArtifactStats.GradientFallbackSamples+=TileAudit.GradientFallbackSamples;
MeshArtifactStats.DetailDisplacementSamples+=TileAudit.DetailDisplacementSamples;
MeshArtifactStats.HighDetailDisplacementSamples+=TileAudit.HighDetailDisplacementSamples;
MeshArtifactStats.DetailDisplacementPatches+=TileAudit.DetailDisplacementPatches;
MeshArtifactStats.MaximumDetailDisplacement=std::max(
MeshArtifactStats.MaximumDetailDisplacement,TileAudit.MaximumDetailDisplacement);
MeshArtifactStats.DetailGradientSamples+=TileAudit.DetailGradientSamples;
MeshArtifactStats.DetailGradientOverLimit+=TileAudit.DetailGradientOverLimit;
MeshArtifactStats.MaximumDetailGradient=std::max(
MeshArtifactStats.MaximumDetailGradient,TileAudit.MaximumDetailGradient);
MeshArtifactStats.CurvedEdgeChecks+=TileAudit.CurvedEdgeChecks;
MeshArtifactStats.CurvedEdgeRootPatches+=TileAudit.CurvedEdgeRootPatches;
MeshArtifactStats.CurvedEdgeRootBadVertices+=TileAudit.CurvedEdgeRootBadVertices;
MeshArtifactStats.MaximumCurvedEdgeRootError=std::max(
MeshArtifactStats.MaximumCurvedEdgeRootError,
TileAudit.MaximumCurvedEdgeRootError);
MeshArtifactStats.FieldEdgeChecks+=TileAudit.FieldEdgeChecks;
MeshArtifactStats.AnalyticCrossingMisses+=TileAudit.AnalyticCrossingMisses;
MeshArtifactStats.OldInt8RangeEdges+=TileAudit.OldInt8RangeEdges;
MeshArtifactStats.NormalChecks+=TileAudit.NormalChecks;
MeshArtifactStats.SumAbsSourceResidual+=TileAudit.SumAbsSourceResidual;
MeshArtifactStats.SumAnalyticEdgeShiftVoxels+=TileAudit.SumAnalyticEdgeShiftVoxels;
if(TileAudit.MaximumAnalyticEdgeShiftVoxels
>MeshArtifactStats.MaximumAnalyticEdgeShiftVoxels)
{
MeshArtifactStats.MaximumAnalyticEdgeShiftVoxels=TileAudit.MaximumAnalyticEdgeShiftVoxels;
MeshArtifactStats.WorstShiftPosition=TileAudit.WorstShiftPosition;
MeshArtifactStats.WorstShiftFraction=TileAudit.WorstShiftFraction;
MeshArtifactStats.WorstShiftD0=TileAudit.WorstShiftD0;
MeshArtifactStats.WorstShiftD1=TileAudit.WorstShiftD1;
MeshArtifactStats.WorstShiftExactD0=TileAudit.WorstShiftExactD0;
MeshArtifactStats.WorstShiftExactD1=TileAudit.WorstShiftExactD1;
MeshArtifactStats.WorstShiftAxis=TileAudit.WorstShiftAxis;
}
if(TileAudit.MaximumAbsSourceResidual>MeshArtifactStats.MaximumAbsSourceResidual)
{
MeshArtifactStats.MaximumAbsSourceResidual=TileAudit.MaximumAbsSourceResidual;
MeshArtifactStats.WorstResidualPosition=TileAudit.WorstResidualPosition;
}
MeshArtifactStats.SumNormalAgreement+=TileAudit.SumNormalAgreement;
MeshArtifactStats.MinimumNormalAgreement=std::min(
MeshArtifactStats.MinimumNormalAgreement,TileAudit.MinimumNormalAgreement);
MeshArtifactStats.MaximumAirSkirtDensity=std::max(
MeshArtifactStats.MaximumAirSkirtDensity,TileAudit.MaximumAirSkirtDensity);
MeshArtifactStats.MaximumPatchDominance=std::max(
MeshArtifactStats.MaximumPatchDominance,TileAudit.MaximumPatchDominance);
for(size_t Bin=0;Bin<MeshArtifactStats.OffsetHistogram.size();++Bin)
MeshArtifactStats.OffsetHistogram[Bin]+=TileAudit.OffsetHistogram[Bin];
}
if(bShardAudit&&Level>=1&&CoreWorld)
{
const FCoarsePanelAudit TileAudit=AuditCoarseSurfacePanels(
Tile,*CoreWorld,CoreWorld->configuration(),CoarsePanelStats.OffSurfacePanels<8);
CoarsePanelStats.Tiles+=TileAudit.Tiles;
CoarsePanelStats.PlanarOpenComponents+=TileAudit.PlanarOpenComponents;
CoarsePanelStats.OffSurfacePanels+=TileAudit.OffSurfacePanels;
CoarsePanelStats.Triangles+=TileAudit.Triangles;
CoarsePanelStats.MaximumSourceErrorVoxels=std::max(
CoarsePanelStats.MaximumSourceErrorVoxels,TileAudit.MaximumSourceErrorVoxels);
}
if(!BakeCachePath.empty())CacheTiles.push_back(std::move(Tile));
}
if(!bFullDetailTimeReported&&FullDetailFinished>=FullDetailExpected)
{
bFullDetailTimeReported=true;
FullDetailSeconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-Start).count();
std::vector<FHashedTile> FullRows;
std::vector<FHashedTile> FullMeshRows;
std::vector<FHashedTile> FullPayloadRows;
std::vector<FHashedTile> FullTopologyRows;
for(int32 Level=0;Level<World.FullResClipLevels&&Level<=MaxLevels;++Level)
{
FullRows.insert(FullRows.end(),HashRows[Level].begin(),HashRows[Level].end());
FullMeshRows.insert(FullMeshRows.end(),MeshHashRows[Level].begin(),MeshHashRows[Level].end());
FullPayloadRows.insert(FullPayloadRows.end(),PayloadHashRows[Level].begin(),PayloadHashRows[Level].end());
FullTopologyRows.insert(FullTopologyRows.end(),TopologyHashRows[Level].begin(),TopologyHashRows[Level].end());
}
if(bHashDensity||!BakeCachePath.empty())
std::printf("[StreamFullDetail] wall=%.3fs generated=%d/%d resident_tiles_cpu_only=1 density_hash=0x%016llx mesh_hash=0x%016llx payload_hash=0x%016llx topology_hash=0x%016llx\n",
FullDetailSeconds,FullDetailFinished,FullDetailExpected,
static_cast<unsigned long long>(HashTileRows(FullRows)),
static_cast<unsigned long long>(HashTileRows(FullMeshRows)),
static_cast<unsigned long long>(HashTileRows(FullPayloadRows)),
static_cast<unsigned long long>(HashTileRows(FullTopologyRows)));
else
std::printf("[StreamFullDetail] wall=%.3fs generated=%d/%d resident_tiles_cpu_only=1 hash=off\n",
FullDetailSeconds,FullDetailFinished,FullDetailExpected);
std::fflush(stdout);
}
}
const double FullClipSeconds=std::chrono::duration<double>(
std::chrono::steady_clock::now()-Start).count();
if(!PlayerNeighborhoodTiles.empty()&&PlayerNeighborhoodReady.size()==PlayerNeighborhoodTiles.size())
std::printf("[PlayerNeighborhood] lod0_tiles=%zu/%zu mesh_ready=%.3fs collision_cook=unavailable_in_standalone\n",
PlayerNeighborhoodReady.size(),PlayerNeighborhoodTiles.size(),
std::chrono::duration<double>(PlayerNeighborhoodCompleted-Start).count());
else
std::printf("[PlayerNeighborhood] lod0_tiles=%zu/%zu mesh_ready=missing collision_cook=unavailable_in_standalone\n",
PlayerNeighborhoodReady.size(),PlayerNeighborhoodTiles.size());
const double TotalWorkerSeconds=std::accumulate(WorkerSecondsByLevel.begin(),WorkerSecondsByLevel.end(),0.0);
const uint64 TotalMeshPayloadAllocatedBytes=std::accumulate(
MeshPayloadAllocatedBytesByLevel.begin(),MeshPayloadAllocatedBytesByLevel.end(),uint64{0});
const uint64 TotalViewerOutputBytes=std::accumulate(
OutputBytesByLevel.begin(),OutputBytesByLevel.end(),uint64{0});
const double WorkerBusyPercent=100.0*TotalWorkerSeconds
/(std::max(1,WorkerCount)*std::max(0.001,FullClipSeconds));
std::vector<FHashedTile> AllRows;
std::vector<FHashedTile> AllMeshRows;
std::vector<FHashedTile> AllPayloadRows;
std::vector<FHashedTile> AllTopologyRows;
if(bHashDensity||!BakeCachePath.empty())
for(int32 Level=0;Level<=MaxLevels;++Level)
{
AllRows.insert(AllRows.end(),HashRows[Level].begin(),HashRows[Level].end());
AllMeshRows.insert(AllMeshRows.end(),MeshHashRows[Level].begin(),MeshHashRows[Level].end());
AllPayloadRows.insert(AllPayloadRows.end(),PayloadHashRows[Level].begin(),PayloadHashRows[Level].end());
AllTopologyRows.insert(AllTopologyRows.end(),TopologyHashRows[Level].begin(),TopologyHashRows[Level].end());
}
if(bHashDensity||!BakeCachePath.empty())
std::printf("[StreamFullClipmap] wall=%.3fs generated=%d/%d worker_sum=%.3fs worker_busy=%.1f%% worker_idle=%.1f%% payload_alloc=%.2fMiB viewer_output=%.2fMiB tiles=%d density_hash=0x%016llx mesh_hash=0x%016llx payload_hash=0x%016llx topology_hash=0x%016llx\n",
FullClipSeconds,Finished,DesiredTotal,TotalWorkerSeconds,WorkerBusyPercent,
std::max(0.0,100.0-WorkerBusyPercent),
static_cast<double>(TotalMeshPayloadAllocatedBytes)/1048576.0,
static_cast<double>(TotalViewerOutputBytes)/1048576.0,
DesiredTotal,static_cast<unsigned long long>(HashTileRows(AllRows)),
static_cast<unsigned long long>(HashTileRows(AllMeshRows)),
static_cast<unsigned long long>(HashTileRows(AllPayloadRows)),
static_cast<unsigned long long>(HashTileRows(AllTopologyRows)));
else
std::printf("[StreamFullClipmap] wall=%.3fs generated=%d/%d worker_sum=%.3fs worker_busy=%.1f%% worker_idle=%.1f%% payload_alloc=%.2fMiB viewer_output=%.2fMiB tiles=%d hash=off\n",
FullClipSeconds,Finished,DesiredTotal,TotalWorkerSeconds,WorkerBusyPercent,
std::max(0.0,100.0-WorkerBusyPercent),
static_cast<double>(TotalMeshPayloadAllocatedBytes)/1048576.0,
static_cast<double>(TotalViewerOutputBytes)/1048576.0,DesiredTotal);
std::printf("[StreamCacheUse] hits=%llu requested=%d\n",
static_cast<unsigned long long>(Streamer.GetCacheHits()),DesiredTotal);
if(bShardAudit)
std::printf("[ThinMeshShardAudit] level=0 tiles=%llu view_components=%llu small_components=%llu isolated_in_view_small=%llu boundary_in_view_small=%llu thin_sheets=%llu sheet_triangles=%llu thickness_lt=1.000 vox pca_scale=3.5x_sigma status=%s\n",
static_cast<unsigned long long>(MeshAuditedTiles),
static_cast<unsigned long long>(MeshSheetStats.Components),
static_cast<unsigned long long>(MeshSheetStats.SmallComponents),
static_cast<unsigned long long>(MeshSheetStats.SmallComponentsInView),
static_cast<unsigned long long>(MeshSheetStats.BoundarySmallComponentsInView),
static_cast<unsigned long long>(MeshSheetStats.ThinSheets),
static_cast<unsigned long long>(MeshSheetStats.TrianglesInThinSheets),
MeshSheetStats.ThinSheets==0&&MeshSheetStats.SmallComponentsInView==0?"PASS":"FAIL");
if(bShardAudit&&CoreWorld)
{
const double MidpointShare=MeshArtifactStats.EdgeVertices
?100.0*static_cast<double>(MeshArtifactStats.MidpointVertices)
/MeshArtifactStats.EdgeVertices:0.0;
const double MeanSourceResidual=MeshArtifactStats.FieldEdgeChecks
?MeshArtifactStats.SumAbsSourceResidual/MeshArtifactStats.FieldEdgeChecks:0.0;
const double MeanAnalyticEdgeShift=MeshArtifactStats.FieldEdgeChecks
?MeshArtifactStats.SumAnalyticEdgeShiftVoxels
/std::max<uint64>(1,MeshArtifactStats.FieldEdgeChecks-MeshArtifactStats.AnalyticCrossingMisses):0.0;
const double MeanNormalAgreement=MeshArtifactStats.NormalChecks
?MeshArtifactStats.SumNormalAgreement/MeshArtifactStats.NormalChecks:1.0;
std::printf("[MeshFieldFitAudit] edge_checks=%llu analytic_crossing_misses=%llu old_int8_range_edges=%llu source_residual_mean=%.4f max=%.4f vox analytic_edge_shift_mean=%.4f max=%.4f vox sampled_normal_dot_mean=%.4f min=%.4f\n",
static_cast<unsigned long long>(MeshArtifactStats.FieldEdgeChecks),
static_cast<unsigned long long>(MeshArtifactStats.AnalyticCrossingMisses),
static_cast<unsigned long long>(MeshArtifactStats.OldInt8RangeEdges),
MeanSourceResidual,MeshArtifactStats.MaximumAbsSourceResidual,
MeanAnalyticEdgeShift,MeshArtifactStats.MaximumAnalyticEdgeShiftVoxels,
MeanNormalAgreement,MeshArtifactStats.MinimumNormalAgreement);
std::printf("[MeshFieldFitWorst] shift=%.4f vox vertex=(%.3f,%.3f,%.3f) axis=%d fraction=%.4f packed=(%.4f,%.4f) analytic=(%.4f,%.4f) max_source_residual=%.4f vox vertex=(%.3f,%.3f,%.3f)\n",
MeshArtifactStats.MaximumAnalyticEdgeShiftVoxels,
MeshArtifactStats.WorstShiftPosition[0],MeshArtifactStats.WorstShiftPosition[1],
MeshArtifactStats.WorstShiftPosition[2],MeshArtifactStats.WorstShiftAxis,
MeshArtifactStats.WorstShiftFraction,MeshArtifactStats.WorstShiftD0,
MeshArtifactStats.WorstShiftD1,MeshArtifactStats.WorstShiftExactD0,
MeshArtifactStats.WorstShiftExactD1,MeshArtifactStats.MaximumAbsSourceResidual,
MeshArtifactStats.WorstResidualPosition[0],MeshArtifactStats.WorstResidualPosition[1],
MeshArtifactStats.WorstResidualPosition[2]);
// The restored four-voxel relief creates sparse edge-curvature misses across
// the full 512-tile view. Keep the connected-block rejection strict, while
// allowing up to 4% scattered misses that do not form a visible patch.
const uint64 RootBadLimit=std::max<uint64>(64,
MeshArtifactStats.CurvedEdgeChecks*40u/1000u);
const double RootBadShare=MeshArtifactStats.CurvedEdgeChecks
?static_cast<double>(MeshArtifactStats.CurvedEdgeRootBadVertices)
/MeshArtifactStats.CurvedEdgeChecks:0.0;
const bool bRootAuditPass=MeshArtifactStats.CurvedEdgeRootPatches==0
&&MeshArtifactStats.CurvedEdgeRootBadVertices<=RootBadLimit;
std::printf("[MeshCurvedEdgeRootAudit] midpoint_edges=%llu bad_vertices=%llu bad_share=%.3f%% allowed=%llu patches=%llu max_midpoint_root_error=%.4f vox error_threshold=0.080 status=%s\n",
static_cast<unsigned long long>(MeshArtifactStats.CurvedEdgeChecks),
static_cast<unsigned long long>(MeshArtifactStats.CurvedEdgeRootBadVertices),
RootBadShare*100.0,static_cast<unsigned long long>(RootBadLimit),
static_cast<unsigned long long>(MeshArtifactStats.CurvedEdgeRootPatches),
MeshArtifactStats.MaximumCurvedEdgeRootError,
bRootAuditPass?"PASS":"FAIL");
std::printf("[MeshDetailGradientAudit] overlap_samples=%llu over_limit=%llu max_gradient=%.4f vox_per_vox limit=0.550 status=%s\n",
static_cast<unsigned long long>(MeshArtifactStats.DetailGradientSamples),
static_cast<unsigned long long>(MeshArtifactStats.DetailGradientOverLimit),
MeshArtifactStats.MaximumDetailGradient,
MeshArtifactStats.DetailGradientOverLimit==0?"PASS":"FAIL");
std::printf("[MeshSurfaceArtifactAudit] levels=0,1 tiles=%llu surface_vertices=%llu edge_vertices=%llu midpoint_band_vertices=%llu midpoint_share=%.2f%% visible_skirt_triangles=%llu hidden_same_lod_skirt_triangles=%llu exposed_skirt_triangles=%llu reverse_side_solid=%llu max_air_density=%.3f vox repeated_offset_patches=%llu field_residual_patches=%llu normal_mismatch_patches=%llu gradient_fallback_patches=%llu fallback_gradient_samples=%llu high_detail_vertices=%llu/%llu high_detail_patches=%llu max_detail_displacement=%.3f vox max_patch_dominance=%.3f status=%s\n",
static_cast<unsigned long long>(MeshArtifactStats.Tiles),
static_cast<unsigned long long>(MeshArtifactStats.SurfaceVertices),
static_cast<unsigned long long>(MeshArtifactStats.EdgeVertices),
static_cast<unsigned long long>(MeshArtifactStats.MidpointVertices),MidpointShare,
static_cast<unsigned long long>(MeshArtifactStats.SkirtTriangles),
static_cast<unsigned long long>(MeshArtifactStats.HiddenSameLodSkirtTriangles),
static_cast<unsigned long long>(MeshArtifactStats.ExposedSkirtTriangles),
static_cast<unsigned long long>(MeshArtifactStats.ReverseSideSolidSkirtTriangles),
MeshArtifactStats.MaximumAirSkirtDensity,
static_cast<unsigned long long>(MeshArtifactStats.RepeatedOffsetPatches),
static_cast<unsigned long long>(MeshArtifactStats.FieldMismatchPatches),
static_cast<unsigned long long>(MeshArtifactStats.NormalMismatchPatches),
static_cast<unsigned long long>(MeshArtifactStats.GradientFallbackPatches),
static_cast<unsigned long long>(MeshArtifactStats.GradientFallbackSamples),
static_cast<unsigned long long>(MeshArtifactStats.HighDetailDisplacementSamples),
static_cast<unsigned long long>(MeshArtifactStats.DetailDisplacementSamples),
static_cast<unsigned long long>(MeshArtifactStats.DetailDisplacementPatches),
MeshArtifactStats.MaximumDetailDisplacement,
MeshArtifactStats.MaximumPatchDominance,
MeshArtifactStats.ExposedSkirtTriangles==0&&MeshArtifactStats.RepeatedOffsetPatches==0
&&MeshArtifactStats.FieldMismatchPatches==0
&&MeshArtifactStats.NormalMismatchPatches==0
&&MeshArtifactStats.GradientFallbackPatches==0
&&MeshArtifactStats.DetailDisplacementPatches==0
&&bRootAuditPass
&&MeshArtifactStats.DetailGradientOverLimit==0?"PASS":"FAIL");
std::printf("[CoarsePanelAudit] tiles=%llu planar_open_components=%llu off_surface_panels=%llu panel_triangles=%llu max_source_error=%.3f vox status=%s\n",
static_cast<unsigned long long>(CoarsePanelStats.Tiles),
static_cast<unsigned long long>(CoarsePanelStats.PlanarOpenComponents),
static_cast<unsigned long long>(CoarsePanelStats.OffSurfacePanels),
static_cast<unsigned long long>(CoarsePanelStats.Triangles),
CoarsePanelStats.MaximumSourceErrorVoxels,
CoarsePanelStats.OffSurfacePanels==0?"PASS":"FAIL");
}
for(int32 Level=0;Level<=MaxLevels;++Level)
{
if(TilesByLevel[Level]==0)continue;
if(bHashDensity||!BakeCachePath.empty())
std::printf("[StreamLevel] lod=%d tiles=%llu samples=%.3fM worker_sum=%.3fs first_ready=%.3fs complete=%.3fs worker_busy=%.1f%% payload_alloc=%.2fMiB viewer_output=%.2fMiB vertices=%llu indices=%llu density_hash=0x%016llx mesh_hash=0x%016llx payload_hash=0x%016llx topology_hash=0x%016llx\n",
Level,static_cast<unsigned long long>(TilesByLevel[Level]),
static_cast<double>(SamplesByLevel[Level])/1.0e6,WorkerSecondsByLevel[Level],
FirstCompletionByLevel[Level],LastCompletionByLevel[Level],
100.0*WorkerSecondsByLevel[Level]/(WorkerCount*std::max(0.001,LastCompletionByLevel[Level])),
static_cast<double>(MeshPayloadAllocatedBytesByLevel[Level])/1048576.0,
static_cast<double>(OutputBytesByLevel[Level])/1048576.0,
static_cast<unsigned long long>(VerticesByLevel[Level]),
static_cast<unsigned long long>(IndicesByLevel[Level]),
static_cast<unsigned long long>(HashTileRows(HashRows[Level])),
static_cast<unsigned long long>(HashTileRows(MeshHashRows[Level])),
static_cast<unsigned long long>(HashTileRows(PayloadHashRows[Level])),
static_cast<unsigned long long>(HashTileRows(TopologyHashRows[Level])));
else
std::printf("[StreamLevel] lod=%d tiles=%llu samples=%.3fM worker_sum=%.3fs first_ready=%.3fs complete=%.3fs worker_busy=%.1f%% payload_alloc=%.2fMiB viewer_output=%.2fMiB vertices=%llu indices=%llu hash=off\n",
Level,static_cast<unsigned long long>(TilesByLevel[Level]),
static_cast<double>(SamplesByLevel[Level])/1.0e6,WorkerSecondsByLevel[Level],
FirstCompletionByLevel[Level],LastCompletionByLevel[Level],
100.0*WorkerSecondsByLevel[Level]/(WorkerCount*std::max(0.001,LastCompletionByLevel[Level])),
static_cast<double>(MeshPayloadAllocatedBytesByLevel[Level])/1048576.0,
static_cast<double>(OutputBytesByLevel[Level])/1048576.0,
static_cast<unsigned long long>(VerticesByLevel[Level]),
static_cast<unsigned long long>(IndicesByLevel[Level]));
}
if(!BakeCachePath.empty())
{
std::string CacheError;
if(!FStandaloneMeshCache::Save(BakeCachePath,CacheMetadata,CacheTiles,CacheError))
{
std::fprintf(stderr,"[MeshCacheBake] failed: %s\n",CacheError.c_str());
return 8;
}
const uint64 Bytes=std::filesystem::file_size(BakeCachePath);
std::printf("[MeshCacheBake] saved %zu tiles, %.2f MiB to %s\n",CacheTiles.size(),
static_cast<double>(Bytes)/1048576.0,BakeCachePath.c_str());
}
if(Finished!=DesiredTotal||FullDetailFinished!=FullDetailExpected)return 6;
if(bShardAudit&&(MeshSheetStats.ThinSheets!=0||MeshSheetStats.SmallComponentsInView!=0))return 13;
if(bShardAudit&&CoreWorld&&(MeshArtifactStats.ExposedSkirtTriangles!=0
||MeshArtifactStats.RepeatedOffsetPatches!=0||MeshArtifactStats.FieldMismatchPatches!=0
||MeshArtifactStats.NormalMismatchPatches!=0||MeshArtifactStats.GradientFallbackPatches!=0
||MeshArtifactStats.CurvedEdgeRootPatches!=0
||MeshArtifactStats.CurvedEdgeRootBadVertices>std::max<uint64>(
64,MeshArtifactStats.CurvedEdgeChecks*40u/1000u)
||MeshArtifactStats.DetailGradientOverLimit!=0))return 13;
if(bShardAudit&&CoreWorld&&CoarsePanelStats.OffSurfacePanels!=0)return 13;
if(FarAudit)
{
FarAudit->Finalize();
FarAudit->Print();
if(!FarAudit->Passing())return 14;
}
return 0;
}
int RunEditTransactionBenchmark(FStandaloneOwnerWorld& World,VoxelForgeCore::World& Shape,
const FVector& CameraPositionVoxels,int32 WorkerCount)
{
using Clock=std::chrono::steady_clock;
// Place the spell across the LOD0/LOD1 clipmap seam so one edit exercises every visible
// level it intersects, instead of timing only the center LOD0 tiles.
const double X=CameraPositionVoxels.X+3.0*CHUNK_SIZE;
const double Y=CameraPositionVoxels.Y,Z=CameraPositionVoxels.Z;
FStandaloneDesiredTileSet Desired=StandaloneWorldMesher::BuildDesiredSet(World,CameraPositionVoxels);
const auto CoreDesired=Shape.desiredTiles(
{CameraPositionVoxels.X,CameraPositionVoxels.Y,CameraPositionVoxels.Z});
Desired.Tiles.clear();Desired.Tiles.reserve(CoreDesired.size());
std::vector<VoxelForgeCore::TileKey> CoreKeys;CoreKeys.reserve(CoreDesired.size());
for(const auto& Key:CoreDesired)
{
Desired.Tiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
CoreKeys.push_back(Key);
}
VoxelForgeCore::EditTransaction Transaction;Transaction.sequence=1;Transaction.brushes.resize(3);
Transaction.brushes[0].shape=VoxelForgeCore::EditBrush::Shape::sphere;
Transaction.brushes[0].operation=VoxelForgeCore::EditBrush::Operation::carve;
Transaction.brushes[0].a={X,Y,Z};Transaction.brushes[0].radius=20.0;
Transaction.brushes[1].shape=VoxelForgeCore::EditBrush::Shape::roundedBox;
Transaction.brushes[1].operation=VoxelForgeCore::EditBrush::Operation::carve;
Transaction.brushes[1].a={X,Y,Z+12.0};Transaction.brushes[1].halfExtent={11.0,11.0,4.0};
Transaction.brushes[1].rounding=3.0;
Transaction.brushes[2].shape=VoxelForgeCore::EditBrush::Shape::capsule;
Transaction.brushes[2].operation=VoxelForgeCore::EditBrush::Operation::addRock;
Transaction.brushes[2].a={X-22.0,Y,Z-8.0};Transaction.brushes[2].b={X+22.0,Y,Z-8.0};
Transaction.brushes[2].radius=3.0;
const auto EditStart=Clock::now();
std::string EditError;
const auto Edit=Shape.applyEditTransaction(Transaction,CoreKeys,EditError);
if(!Edit){std::fprintf(stderr,"[EditTransaction] rejected: %s\n",EditError.c_str());return 9;}
std::vector<FVoxelTileKey> Affected;Affected.reserve(128);
std::array<uint64,MaxLevels+1> AffectedByLevel{},FinishedByLevel{};
for(const auto& LodTiles:Edit->affectedByLod)
{
for(const auto& Key:LodTiles)
{
const FVoxelTileKey Tile(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
Affected.push_back(Tile);
if(Tile.Level>=0&&Tile.Level<=MaxLevels)++AffectedByLevel[Tile.Level];
}
}
if(Affected.empty())
{
std::fprintf(stderr,"[EditTransaction] failed: no desired tiles intersect the edit bounds.\n");
return 9;
}
FStandaloneStreamingGenerator Streamer(World,WorkerCount,false,nullptr,-1,
false,false,false,false,&Shape);
Streamer.SetDesiredTileFilter(Affected);
const auto Start=Clock::now();
const FStandaloneStreamingUpdate Update=Streamer.Start(CameraPositionVoxels);
int32 Finished=0;
double WorkerSeconds=0.0;
while(Finished<Update.DesiredTiles)
{
std::vector<FStandaloneCpuTile> Ready=Streamer.TakeReady();
if(Ready.empty()){std::this_thread::sleep_for(std::chrono::milliseconds(1));continue;}
for(const FStandaloneCpuTile& Tile:Ready)
{
++Finished;WorkerSeconds+=Tile.WorkerSeconds;
if(Tile.Key.Level>=0&&Tile.Key.Level<=MaxLevels)++FinishedByLevel[Tile.Key.Level];
}
}
const double RemeshWall=std::chrono::duration<double>(Clock::now()-Start).count();
Streamer.Stop();
std::printf("[EditTransaction] operation=crater_batch transaction_count=1 brushes=3 diameter=10.0m offset_from_player=%.2fm affected_tiles=%d/%zu workers=%d cache_hits=%llu remesh_wall=%.3fs worker_sum=%.3fs edit_to_ready=%.3fs status=%s\n",
3.0*CHUNK_SIZE*VOXEL_SIZE/100.0,
Finished,Affected.size(),WorkerCount,static_cast<unsigned long long>(Streamer.GetCacheHits()),
RemeshWall,WorkerSeconds,std::chrono::duration<double>(Clock::now()-EditStart).count(),
Finished==static_cast<int32>(Affected.size())?"PASS":"FAIL");
for(int32 Level=0;Level<=MaxLevels;++Level)
if(AffectedByLevel[Level])
std::printf("[EditTransactionLevel] lod=%d tiles=%llu remeshed=%llu status=%s\n",Level,
static_cast<unsigned long long>(AffectedByLevel[Level]),
static_cast<unsigned long long>(FinishedByLevel[Level]),
AffectedByLevel[Level]==FinishedByLevel[Level]?"PASS":"FAIL");
return Finished==static_cast<int32>(Affected.size())?0:10;
}
bool MakeRegionBuildRequest(std::span<const VoxelForgeCore::TileKey> tiles,
const VoxelForgeCore::WorldConfiguration& config,int32 workers,
VoxelForgeCore::DetailVariant detail,bool roundTunnels,bool enhancedWalls,
VoxelForgeCore::ShapeBuildRequest& request,std::string& error)
{
FIntVector fineMin(MAX_int32,MAX_int32,MAX_int32),fineMax(MIN_int32,MIN_int32,MIN_int32);
FIntVector clipMin(MAX_int32,MAX_int32,MAX_int32),clipMax(MIN_int32,MIN_int32,MIN_int32);
for(const auto& key:tiles)
{
if(key.lod<0||key.lod>8){error="desired tile has an invalid LOD";return false;}
const int32 extent=CHUNK_SIZE<<key.lod;
const FIntVector origin(
static_cast<int32>(static_cast<int64>(key.coordinate.x)*extent),
static_cast<int32>(static_cast<int64>(key.coordinate.y)*extent),
static_cast<int32>(static_cast<int64>(key.coordinate.z)*extent));
for(int32 axis=0;axis<3;++axis)
{
(&clipMin.X)[axis]=std::min((&clipMin.X)[axis],(&origin.X)[axis]);
(&clipMax.X)[axis]=std::max((&clipMax.X)[axis],(&origin.X)[axis]+extent);
if(key.lod<config.fullResolutionLodCount)
{
(&fineMin.X)[axis]=std::min((&fineMin.X)[axis],(&origin.X)[axis]);
(&fineMax.X)[axis]=std::max((&fineMax.X)[axis],(&origin.X)[axis]+extent);
}
}
}
if(fineMin.X==MAX_int32||clipMin.X==MAX_int32)
{error="desired region contains no fine tiles or clip bounds";return false;}
request.minVoxel={fineMin.X,fineMin.Y,fineMin.Z};
request.maxVoxel={fineMax.X,fineMax.Y,fineMax.Z};
request.clipMinVoxel={clipMin.X,clipMin.Y,clipMin.Z};
request.clipMaxVoxel={clipMax.X,clipMax.Y,clipMax.Z};
request.workerLimit=static_cast<uint32>(std::clamp(workers,1,8));
request.detail=detail;request.roundTunnels=roundTunnels;
request.enhancedTunnelWalls=enhancedWalls;request.includeFarWorld=false;
return true;
}
int RunTilePathHashAudit(VoxelForgeCore::World& base,
const VoxelForgeCore::ResolvedWorldSnapshot& snapshot,
const VoxelForgeCore::JobScheduler& scheduler,const FVector& camera,
int32 workers,VoxelForgeCore::DetailVariant detail,bool roundTunnels,
bool enhancedWalls)
{
const auto baseTiles=base.desiredTiles({camera.X,camera.Y,camera.Z});
const auto& config=base.configuration();
if(baseTiles.empty())
{std::fprintf(stderr,"[TilePathHashAudit] camera window is empty.\n");return 11;}
constexpr int32 TargetChunkOffset=40;
const int32 CameraChunkX=FMath::FloorToInt(camera.X/CHUNK_SIZE);
const int32 CameraChunkY=FMath::FloorToInt(camera.Y/CHUNK_SIZE);
const int32 CameraChunkZ=FMath::FloorToInt(camera.Z/CHUNK_SIZE);
const VoxelForgeCore::TileKey target{{CameraChunkX+TargetChunkOffset,
CameraChunkY,CameraChunkZ},0};
const FVector alternateCamera((target.coordinate.x+0.5)*CHUNK_SIZE,camera.Y,camera.Z);
const auto alternateTiles=base.desiredTiles(
{alternateCamera.X,alternateCamera.Y,alternateCamera.Z});
if(alternateTiles.empty())
{std::fprintf(stderr,"[TilePathHashAudit] target camera window is empty.\n");return 11;}
VoxelForgeCore::TileGenerationOptions options;options.hashDensity=true;
std::string error;
const std::array<VoxelForgeCore::TileKey,1> pageTiles={target};
std::size_t pageTilesA=0;
if(!base.compileTileRegion(pageTiles,static_cast<uint32>(std::clamp(workers,1,8)),
scheduler,error,&pageTilesA,nullptr,false))
{std::fprintf(stderr,"[TilePathHashAudit] path-A page compile failed: %s\n",error.c_str());return 11;}
auto pathA=base.generateTile(target,options,error);
if(!pathA){std::fprintf(stderr,"[TilePathHashAudit] path-A generation failed: %s\n",error.c_str());return 11;}
VoxelForgeCore::World alternate(snapshot);
VoxelForgeCore::ShapeBuildRequest alternateRequest;
if(!MakeRegionBuildRequest(alternateTiles,config,workers,detail,roundTunnels,
enhancedWalls,alternateRequest,error)
||!alternate.compile(alternateRequest,scheduler,error))
{std::fprintf(stderr,"[TilePathHashAudit] alternate camera compile failed: %s\n",error.c_str());return 11;}
std::size_t pageTilesB=0;
auto pathB=alternate.generateTile(target,options,error);
if(!pathB){std::fprintf(stderr,"[TilePathHashAudit] path-B generation failed: %s\n",error.c_str());return 11;}
const auto Same=[&](const VoxelForgeCore::TileMesh& a,const VoxelForgeCore::TileMesh& b)
{
return a.densityHash==b.densityHash&&a.meshHash==b.meshHash
&&a.payloadHash==b.payloadHash&&a.topologyHash==b.topologyHash;
};
const int32 CameraDeltaX=static_cast<int32>(std::lround(alternateCamera.X-camera.X));
const bool pass=pageTilesA==1&&pageTilesB==0&&Same(*pathA,*pathB);
std::printf("[TilePathHashAudit] tile=(%d,%d,%d) lod=%d path_a=late_page path_b=initial_base camera_delta_vox=(%d,0,0) page_covered_tiles=(%zu,%zu) density=(0x%016llx,0x%016llx) mesh=(0x%016llx,0x%016llx) payload=(0x%016llx,0x%016llx) topology=(0x%016llx,0x%016llx) status=%s\n",
target.coordinate.x,target.coordinate.y,target.coordinate.z,target.lod,CameraDeltaX,
pageTilesA,pageTilesB,
static_cast<unsigned long long>(pathA->densityHash),
static_cast<unsigned long long>(pathB->densityHash),
static_cast<unsigned long long>(pathA->meshHash),
static_cast<unsigned long long>(pathB->meshHash),
static_cast<unsigned long long>(pathA->payloadHash),
static_cast<unsigned long long>(pathB->payloadHash),
static_cast<unsigned long long>(pathA->topologyHash),
static_cast<unsigned long long>(pathB->topologyHash),pass?"PASS":"FAIL");
VoxelForgeCore::World analyticForward(snapshot),analyticReverse(snapshot);
VoxelForgeCore::ShapeBuildRequest forwardRequest,reverseRequest;
const FVector reverseCamera((target.coordinate.x+TargetChunkOffset+0.5)*CHUNK_SIZE,
camera.Y,camera.Z);
const auto reverseTiles=base.desiredTiles(
{reverseCamera.X,reverseCamera.Y,reverseCamera.Z});
if(!MakeRegionBuildRequest(baseTiles,config,workers,detail,roundTunnels,
enhancedWalls,forwardRequest,error)
||!analyticForward.compile(forwardRequest,scheduler,error)
||reverseTiles.empty()
||!MakeRegionBuildRequest(reverseTiles,config,workers,detail,roundTunnels,
enhancedWalls,reverseRequest,error)
||!analyticReverse.compile(reverseRequest,scheduler,error))
{std::fprintf(stderr,"[TilePathHashDirections] setup failed: %s\n",error.c_str());return 11;}
std::size_t analyticForwardCovered=0,analyticReverseCovered=0;
VoxelForgeCore::TileRegionCompileStats forwardStats,reverseStats;
if(!analyticForward.compileTileRegion(pageTiles,static_cast<uint32>(std::clamp(workers,1,8)),
scheduler,error,&analyticForwardCovered,&forwardStats,true)
||!analyticReverse.compileTileRegion(pageTiles,static_cast<uint32>(std::clamp(workers,1,8)),
scheduler,error,&analyticReverseCovered,&reverseStats,true))
{std::fprintf(stderr,"[TilePathHashDirections] region compile failed: %s\n",error.c_str());return 11;}
auto analyticPathForward=analyticForward.generateTile(target,options,error);
auto analyticPathReverse=analyticReverse.generateTile(target,options,error);
if(!analyticPathForward||!analyticPathReverse)
{std::fprintf(stderr,"[TilePathHashDirections] tile generation failed: %s\n",error.c_str());return 11;}
const bool analyticDirectionsSame=Same(*analyticPathForward,*analyticPathReverse);
const bool packedAnalyticRenderSame=pathA->meshHash==analyticPathForward->meshHash
&&pathA->payloadHash==analyticPathForward->payloadHash
&&pathA->topologyHash==analyticPathForward->topologyHash;
const bool packedAnalyticDensitySame=pathA->densityHash==analyticPathForward->densityHash;
std::printf("[TilePathHashDirections] tile=(%d,%d,%d) lod=%d approach_deltas=(-%d,+%d) regions=(%zu,%zu) density=(0x%016llx,0x%016llx) mesh=(0x%016llx,0x%016llx) payload=(0x%016llx,0x%016llx) topology=(0x%016llx,0x%016llx) status=%s\n",
target.coordinate.x,target.coordinate.y,target.coordinate.z,target.lod,
TargetChunkOffset,TargetChunkOffset,analyticForwardCovered,analyticReverseCovered,
static_cast<unsigned long long>(analyticPathForward->densityHash),
static_cast<unsigned long long>(analyticPathReverse->densityHash),
static_cast<unsigned long long>(analyticPathForward->meshHash),
static_cast<unsigned long long>(analyticPathReverse->meshHash),
static_cast<unsigned long long>(analyticPathForward->payloadHash),
static_cast<unsigned long long>(analyticPathReverse->payloadHash),
static_cast<unsigned long long>(analyticPathForward->topologyHash),
static_cast<unsigned long long>(analyticPathReverse->topologyHash),
analyticDirectionsSame&&analyticForwardCovered==1&&analyticReverseCovered==1?"PASS":"FAIL");
std::printf("[TilePathPackedAnalyticParity] tile=(%d,%d,%d) density=(0x%016llx,0x%016llx) density_representation=%s mesh=(0x%016llx,0x%016llx) payload=(0x%016llx,0x%016llx) topology=(0x%016llx,0x%016llx) status=%s\n",
target.coordinate.x,target.coordinate.y,target.coordinate.z,
static_cast<unsigned long long>(pathA->densityHash),
static_cast<unsigned long long>(analyticPathForward->densityHash),
packedAnalyticDensitySame?"same":"different",
static_cast<unsigned long long>(pathA->meshHash),
static_cast<unsigned long long>(analyticPathForward->meshHash),
static_cast<unsigned long long>(pathA->payloadHash),
static_cast<unsigned long long>(analyticPathForward->payloadHash),
static_cast<unsigned long long>(pathA->topologyHash),
static_cast<unsigned long long>(analyticPathForward->topologyHash),
packedAnalyticRenderSame?"PASS":"FAIL");
return pass&&analyticDirectionsSame&&analyticForwardCovered==1
&&analyticReverseCovered==1&&packedAnalyticRenderSame?0:12;
}
}
int main(int Argc,char** Argv)
{
SetPriorityClass(GetCurrentProcess(),BELOW_NORMAL_PRIORITY_CLASS);
SetProcessAffinityMask(GetCurrentProcess(),static_cast<DWORD_PTR>(0xFF00));
const auto ColdProcessStart=std::chrono::steady_clock::now();
FApp App;App.DataPath=DefaultDataPath().string();App.ColdProcessStart=ColdProcessStart;
wchar_t ExecutablePath[MAX_PATH]{};
const DWORD ExecutablePathLength=GetModuleFileNameW(nullptr,ExecutablePath,MAX_PATH);
if(ExecutablePathLength>0&&ExecutablePathLength<MAX_PATH)
App.GpuFarShaderPath=std::filesystem::path(ExecutablePath).parent_path().parent_path()
/"Research"/"OwnerShapeWorld"/"gpu_first_port"/"VoxelForgeGpuMesher.hlsl";
std::string JoinedCommandLine;
for(int32 I=1;I<Argc;++I)
{if(!JoinedCommandLine.empty())JoinedCommandLine.push_back(' ');JoinedCommandLine+=Argv[I];}
FCommandLine::Set(JoinedCommandLine);
int32 BenchmarkLevel=-1,BenchmarkCount=64,StreamBenchmarkMaxLevel=-1;
int32 MaxClipLevelOverride=-1;
int32 ShapeCompareLevel=-1,ShapeCompareTileLimit=0;
std::string ShapeCompareArea="unlabeled";
bool bStreamBenchmark=false;
bool bStreamPipeline=false;
bool bProfileDetailBand=false;
bool bPassageDetailAuditOnly=false;
bool bGridStairAudit=false;
bool bTilePathHashAudit=false;
bool bShardAudit=false;
bool bFarSurvivalAudit=false;
bool bFarAuditBadShell=false;
bool bStreamHash=false;
bool bSkipUvAndColors=false;
bool bSkipUV=false;
bool bSkipColors=false;
bool bSkipMaterialGroups=false;
bool bEditBenchmark=false;
bool bRoundWallCompare=false;
bool bCheckOwnerReliefBands=false;
int32 RoundCompareTileCount=16;
std::string BakeMeshCachePath;
for(int32 I=1;I<Argc;++I)
{
const std::string_view Arg=Argv[I];
if(Arg.starts_with("--capture="))App.CapturePath=std::string(Arg.substr(10));
else if(Arg=="--profile-attribution")App.bProfileAttribution=true;
else if(Arg=="--profile-detail-band")bProfileDetailBand=true;
else if(Arg=="--compare-evaluators")App.bCompareEvaluators=true;
else if(Arg=="--parity-only")App.bParityOnly=true;
else if(Arg=="--density-hash")App.bDensityHash=true;
else if(Arg=="--shape-world")App.bShapeWorld=true;
else if(Arg=="--gpu-far")App.bGpuFarEnabled=true,App.bShapeWorld=true,App.bForceGenerate=true;
else if(Arg=="--cpu-far")App.bGpuFarEnabled=false,App.bShapeWorld=true,App.bForceGenerate=true;
else if(Arg=="--gpu-far-audit")
{App.bGpuFarEnabled=true;App.bGpuFarAuditEnabled=true;App.bShapeWorld=true;App.bForceGenerate=true;App.bQuitAfterClipmap=true;}
else if(Arg=="--shape-audit")App.bShapeWorld=true,App.bShapeAuditOnly=true;
else if(Arg=="--grid-stair-audit")bGridStairAudit=true,App.bShapeWorld=true;
else if(Arg=="--tile-path-hash-audit")bTilePathHashAudit=true,App.bShapeWorld=true;
else if(Arg=="--passage-wall-detail-audit")
{App.bShapeWorld=true;App.bShapeAuditOnly=true;bPassageDetailAuditOnly=true;}
else if(Arg=="--shape-compare")App.bShapeWorld=true,App.bShapeCompare=true;
else if(Arg.starts_with("--shape-compare-level="))
ShapeCompareLevel=std::atoi(std::string(Arg.substr(std::string_view("--shape-compare-level=").size())).c_str());
else if(Arg.starts_with("--shape-compare-tile-limit="))
ShapeCompareTileLimit=std::max(0,std::atoi(std::string(Arg.substr(std::string_view("--shape-compare-tile-limit=").size())).c_str()));
else if(Arg.starts_with("--shape-compare-area="))
ShapeCompareArea=std::string(Arg.substr(std::string_view("--shape-compare-area=").size()));
else if(Arg=="--owner-relief-band-audit")bCheckOwnerReliefBands=true;
else if(Arg.starts_with("--shape-detail="))
{
const std::string_view Value=Arg.substr(15);
if(Value=="smooth")App.ShapeDetailVariant=VoxelForgeCore::DetailVariant::smooth;
else if(Value=="per-voxel")App.ShapeDetailVariant=VoxelForgeCore::DetailVariant::perVoxel;
else if(Value!="coherent"){std::fprintf(stderr,"Invalid --shape-detail value: %.*s\n",static_cast<int>(Value.size()),Value.data());return 2;}
}
else if(Arg=="--round-tunnels")App.bRoundTunnels=true;
else if(Arg=="--round-tunnels-legacy")
{App.bRoundTunnels=true;App.bRoundTunnelEnhanced=false;}
else if(Arg=="--stream-benchmark")bStreamBenchmark=true;
else if(Arg=="--stream-pipeline")
{bStreamPipeline=true;bStreamBenchmark=true;App.bShapeWorld=true;App.bForceGenerate=true;}
else if(Arg=="--edit-benchmark")
{bEditBenchmark=true;bStreamBenchmark=true;App.bShapeWorld=true;}
else if(Arg=="--stream-hash")bStreamHash=true;
else if(Arg=="--skip-uv-colors")bSkipUvAndColors=true;
else if(Arg=="--skip-uv")bSkipUV=true;
else if(Arg=="--skip-colors")bSkipColors=true;
else if(Arg=="--skip-material-groups")bSkipMaterialGroups=true;
else if(Arg=="--shard-audit")bShardAudit=true;
else if(Arg=="--far-survival-audit")bFarSurvivalAudit=true,App.bShapeWorld=true;
else if(Arg=="--far-audit-bad-shell")
{bFarAuditBadShell=true;bFarSurvivalAudit=true;App.bShapeWorld=true;}
else if(Arg=="--compare-round-walls")
{bRoundWallCompare=true;App.bRoundTunnels=true;}
else if(Arg.starts_with("--round-compare-tiles="))
RoundCompareTileCount=std::max(1,std::atoi(std::string(Arg.substr(22)).c_str()));
else if(Arg=="--force-generate")App.bForceGenerate=true;
else if(Arg.starts_with("--bake-mesh-cache="))
{BakeMeshCachePath=std::string(Arg.substr(18));App.bForceGenerate=true;}
else if(Arg.starts_with("--stream-max-level="))
StreamBenchmarkMaxLevel=std::atoi(std::string(Arg.substr(19)).c_str());
else if(Arg.starts_with("--max-clip-level="))
MaxClipLevelOverride=std::clamp(
std::atoi(std::string(Arg.substr(17)).c_str()),0,8);
else if(Arg=="--test-one-chunk-crossing")
{
App.FlightTargetCrossings=1;
App.bShapeWorld=true;
}
else if(Arg.starts_with("--test-flight-crossings="))
{
App.FlightTargetCrossings=std::max(1,std::atoi(
std::string(Arg.substr(std::string_view("--test-flight-crossings=").size())).c_str()));
App.bShapeWorld=true;
}
else if(Arg.starts_with("--flight-speed-mps="))
App.FlightSpeedMps=std::clamp(std::strtof(
std::string(Arg.substr(std::string_view("--flight-speed-mps=").size())).c_str(),nullptr),
1.0f,256.0f);
else if(Arg=="--capture-after-clipmap")App.bCaptureAfterClipmap=true;
else if(Arg=="--quit-after-clipmap")App.bQuitAfterClipmap=true;
else if(Arg.starts_with("--workers="))
{
const int32 Parsed=std::atoi(std::string(Arg.substr(10)).c_str());
App.WorkerCount=std::clamp(Parsed,1,8);
}
else if(Arg.starts_with("--clip-radius="))
App.ClipRadius=std::clamp(std::atoi(std::string(Arg.substr(14)).c_str()),1,64);
else if(Arg.starts_with("--capture-tile-limit="))
App.CaptureTileLimit=std::clamp(std::atoi(
std::string(Arg.substr(std::string_view("--capture-tile-limit=").size())).c_str()),1,4096);
else if(Arg.starts_with("--benchmark-level="))
BenchmarkLevel=std::atoi(std::string(Arg.substr(18)).c_str());
else if(Arg.starts_with("--benchmark-count="))
BenchmarkCount=std::max(1,std::atoi(std::string(Arg.substr(18)).c_str()));
else if(Arg.starts_with("--camera="))
{
const std::string Values(Arg.substr(9));
float X=0,Y=0,Z=0,YawDegrees=0,PitchDegrees=0;
if(std::sscanf(Values.c_str(),"%f,%f,%f,%f,%f",&X,&Y,&Z,&YawDegrees,&PitchDegrees)==5)
{
App.bHasCameraOverride=true;App.CameraPositionOverride={X,Y,Z};
App.CameraYawOverride=YawDegrees*0.017453292519943295f;
App.CameraPitchOverride=PitchDegrees*0.017453292519943295f;
}
else {std::fprintf(stderr,"Invalid --camera value: %s\n",Values.c_str());return 2;}
}
else if(!Arg.empty()&&Arg.front()!='-')App.DataPath=std::string(Arg);
}
App.bProfileDetailBand=bProfileDetailBand;
std::string Error;
std::printf("[ColdTimeline] stage=owner_data_load begin_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count());
App.World=std::make_shared<FStandaloneOwnerWorld>();
{
std::ifstream JsonFile(App.DataPath,std::ios::binary);
if(!JsonFile){std::fprintf(stderr,"Owner data load failed: cannot open %s\n",App.DataPath.c_str());return 2;}
std::string OwnerJsonText{std::istreambuf_iterator<char>(JsonFile),std::istreambuf_iterator<char>{}};
if(!JsonFile&& !JsonFile.eof())
{std::fprintf(stderr,"Owner data load failed: read error for %s\n",App.DataPath.c_str());return 2;}
if(!VFJson::Parser(std::move(OwnerJsonText)).Parse(App.OwnerJsonRoot,Error))
{std::fprintf(stderr,"Owner data load failed: %s\n",Error.c_str());return 2;}
}
if(!StandaloneOwnerLoader::Resolve(App.OwnerJsonRoot,*App.World,Error))
{std::fprintf(stderr,"Owner data load failed: %s\n",Error.c_str());return 2;}
std::printf("[ColdTimeline] stage=owner_data_load end_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count());
App.Seed=App.World->Seed;
if(App.bParityOnly)
{
VoxelGenLOD::InitializeConsoleSwitches();
return App.PrintParity()==0?0:1;
}
App.Position={static_cast<float>(App.World->ViewerStartVoxels.X*0.25),
static_cast<float>(App.World->ViewerStartVoxels.Y*0.25),static_cast<float>(App.World->ViewerStartVoxels.Z*0.25)};
if(App.bHasCameraOverride){App.Position=App.CameraPositionOverride;App.Yaw=App.CameraYawOverride;App.Pitch=App.CameraPitchOverride;}
const int32 ExportClipRadius=App.World->ClipRadius;
const int32 ExportMaxClipLevel=App.World->MaxClipLevel;
App.World->ClipRadius=App.ClipRadius;
App.World->Settings->ClipRadius=App.ClipRadius;
if(App.bRoundTunnels&&!PrepareStandaloneDensityWorld(*App.World,App.Seed,
App.bRoundTunnels,App.bRoundTunnelEnhanced,Error))
{std::fprintf(stderr,"Standalone world setup failed: %s\n",Error.c_str());return 2;}
if(MaxClipLevelOverride>=0)
{
App.MaxClipLevelOverride=MaxClipLevelOverride;
App.World->MaxClipLevel=MaxClipLevelOverride;
App.World->Settings->MaxClipLevel=MaxClipLevelOverride;
std::printf("Standalone max clip level override: exported=%d -> max_level=%d.\n",
ExportMaxClipLevel,MaxClipLevelOverride);
}
const bool bNeedFarShapeWorld=bStreamBenchmark
?(StreamBenchmarkMaxLevel<0||StreamBenchmarkMaxLevel>=App.World->FullResClipLevels)
:(App.bShapeCompare?ShapeCompareLevel>=App.World->FullResClipLevels
:(BenchmarkLevel>=App.World->FullResClipLevels));
if(App.bShapeWorld&&(App.bShapeAuditOnly||bGridStairAudit||bTilePathHashAudit||App.bShapeCompare||bStreamBenchmark||BenchmarkLevel>=0)
&&!bStreamPipeline
&&!App.BuildShapeWorldForCamera(Error,bNeedFarShapeWorld))
{std::fprintf(stderr,"Shape interval build failed: %s\n",Error.c_str());return 2;}
if(bStreamPipeline)
{
App.Snapshot=VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(App.OwnerJsonRoot,
App.Seed,App.ClipRadius,App.MaxClipLevelOverride,App.bRoundTunnels,
App.bRoundTunnelEnhanced,Error);
if(!App.Snapshot)
{std::fprintf(stderr,"Shape interval build failed: %s\n",Error.c_str());return 2;}
}
if(App.bShapeAuditOnly)
{
if(bPassageDetailAuditOnly)
return App.ShapeWorld->auditSurfaceFamilies(true)?0:8;
const bool bSurfacePassing=App.ShapeWorld->auditViewSurface(
{App.Position.X*4.0,App.Position.Y*4.0,App.Position.Z*4.0},
App.Yaw,App.Pitch);
return App.ShapeWorld->auditDetailPassing()&&bSurfacePassing?0:7;
}
if(bGridStairAudit)
return App.ShapeWorld->auditGridStairIntegrity()?0:9;
if(bTilePathHashAudit)
return RunTilePathHashAudit(*App.ShapeWorld,App.Snapshot,App.CoreScheduler,
FVector(App.Position.X*4.0,App.Position.Y*4.0,App.Position.Z*4.0),
App.WorkerCount,App.ShapeDetailVariant,App.bRoundTunnels,App.bRoundTunnelEnhanced);
if(App.bShapeCompare)
return RunOwnerShapeComparison(*App.World,*App.ShapeWorld,App.Position,App.Yaw,App.Pitch,App.WorkerCount,
ShapeCompareLevel,ShapeCompareTileLimit,ShapeCompareArea,bCheckOwnerReliefBands);
if(bRoundWallCompare)
return RunRoundWallComparison(*App.World,App.Position,RoundCompareTileCount);
if(bStreamBenchmark)
{
if(bStreamPipeline)
return RunPipelinedStreamingBenchmark(App.World,App.Snapshot,
FVector(App.Position.X*4.0,App.Position.Y*4.0,App.Position.Z*4.0),
App.WorkerCount,StreamBenchmarkMaxLevel,App.ShapeDetailVariant,App.CoreScheduler,
bStreamHash||!BakeMeshCachePath.empty(),bSkipUvAndColors,bSkipMaterialGroups,
bSkipUV,bSkipColors,ColdProcessStart);
if(bEditBenchmark)
return RunEditTransactionBenchmark(*App.World,*App.ShapeWorld,
FVector(App.Position.X*4.0,App.Position.Y*4.0,App.Position.Z*4.0),App.WorkerCount);
const double FullDetailWidth=static_cast<double>(2*App.ClipRadius+2)
*CHUNK_SIZE*VOXEL_SIZE/100.0;
std::printf("Standalone clip override: exported radius=%d (112 m cube) -> radius=%d (%.0f m LOD0 cube), voxel size=25 cm.\n",
ExportClipRadius,App.ClipRadius,FullDetailWidth);
if(!App.bForceGenerate&&!App.bShapeWorld)App.LoadMeshCache();
return RunStreamingBenchmark(*App.World,App.ShapeWorld.get(),
FVector(App.Position.X*4.0,App.Position.Y*4.0,App.Position.Z*4.0),
App.WorkerCount,StreamBenchmarkMaxLevel,App.bRoundTunnels,
App.bRoundTunnelEnhanced,(!App.bShapeWorld&&App.MeshCache.IsLoaded())?&App.MeshCache:nullptr,
bStreamHash,bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,bShardAudit,
bFarSurvivalAudit,bFarAuditBadShell,App.Yaw,App.Pitch,
BakeMeshCachePath,App.MakeMeshCacheMetadata());
}
if(BenchmarkLevel>=0)
return RunTileBenchmark(*App.World,App.Position,BenchmarkLevel,BenchmarkCount,
App.bProfileAttribution,App.bCompareEvaluators,App.bDensityHash,App.ShapeWorld.get());
App.World.reset();
WNDCLASSA Class{};Class.lpfnWndProc=WindowProc;Class.hInstance=GetModuleHandleA(nullptr);Class.lpszClassName="VoxelForgeStandaloneWorld";
Class.hCursor=LoadCursor(nullptr,IDC_ARROW);RegisterClassA(&Class);
RECT Rect{0,0,App.Width,App.Height};AdjustWindowRect(&Rect,WS_OVERLAPPEDWINDOW,FALSE);
App.Window=CreateWindowA(Class.lpszClassName,"VoxelForge standalone world",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
Rect.right-Rect.left,Rect.bottom-Rect.top,nullptr,nullptr,Class.hInstance,nullptr);
GApp=&App;
const auto DeviceInitStart=std::chrono::steady_clock::now();
std::printf("[ColdTimeline] stage=viewer_device_init begin_ms=%.3f\n",
std::chrono::duration<double,std::milli>(DeviceInitStart-ColdProcessStart).count());
if(!App.Window||!App.InitializeDevice()){MessageBoxA(nullptr,"Direct3D 11 initialization failed.","VoxelForge standalone",MB_ICONERROR);return 3;}
std::printf("[ColdTimeline] stage=viewer_device_init end_ms=%.3f duration_ms=%.3f\n",
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-ColdProcessStart).count(),
std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-DeviceInitStart).count());
ShowWindow(App.Window,SW_SHOW);UpdateWindow(App.Window);
std::printf("Controls: hold right mouse to look; WASD move; Space/Ctrl (E/Q) up/down; Shift faster; wheel changes speed; F wireframe; G toggles legacy/detailed round walls; H toggles CPU/GPU far tiles; 1-9 toggle LOD; 0 toggle all levels; N/P change seed; T swaps base/round tunnels; V swaps owner density/shape intervals; Esc quit.\n");
std::printf("Owner data: %s; starting at first-strate open-space sample (%.2f, %.2f, %.2f) m.\n",
App.DataPath.c_str(),App.Position.X,App.Position.Y,App.Position.Z);
std::fflush(stdout);
App.StartGeneration();
MSG Message{};
while(Message.message!=WM_QUIT)
{
if(PeekMessage(&Message,nullptr,0,0,PM_REMOVE)){TranslateMessage(&Message);DispatchMessage(&Message);}
else App.Draw();
}
GApp=nullptr;
return 0;
}
Reference in new issue View Git Blame Copy Permalink