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

proto: continuous swept road deck; coarse-LOD proxies keep thin pillars intact (L143)

Browse Source 
Road: one swept-deck stamp on a shared cubic-Hermite centerline (stamp vocabulary V5), 376.8 m, max 8.5 deg, walk
audit clean, short-road control fails as expected. Pillars: regular fillPillar stamps get deterministic 24-sided
capped-cylinder proxies once the LOD step exceeds their radius or half-height (applies to all worlds). Owner hashes
unchanged (v227); five-fixture Clang/GCC determinism; fast tier green.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
This commit is contained in:
Fr0zkaandClaude Opus 5.5 committed 2026-11-01 10:08:37 +01:00
1 parent 6cd9e4da76
commit a4e214561f
19 files changed
+1167 -73
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Standalone/Source/StreamBenchmarkHeadless.cpp
+23 -12
View File
@@ -1935,15 +1935,24 @@ int main(int argc,char** argv)
std::sort(deck.begin(),deck.end(),[](const auto* a,const auto* b)
{return a->stableId<b->stableId;});
double pathLength=0.0,maxGradeDegrees=0.0;
for(std::size_t i=0;i<deck.size();++i)
std::vector<std::array<std::int64_t,3>> centerline;
if(deck.size()==1&&!deck.front()->sweepPathMicrometres.empty())
centerline=deck.front()->sweepPathMicrometres;
else
{
const auto* segment=deck[i];
const double dx=(segment->sweepEndpointsMicrometres[1][0]
-segment->sweepEndpointsMicrometres[0][0])/1.0e6;
const double dy=(segment->sweepEndpointsMicrometres[1][1]
-segment->sweepEndpointsMicrometres[0][1])/1.0e6;
const double dz=std::abs(segment->sweepEndpointsMicrometres[1][2]
-segment->sweepEndpointsMicrometres[0][2])/1.0e6;
for(std::size_t i=0;i<deck.size();++i)
{
const auto* segment=deck[i];
if(i==0)centerline.push_back(segment->sweepEndpointsMicrometres[0]);
centerline.push_back(segment->sweepEndpointsMicrometres[1]);
}
}
for(std::size_t i=1;i<centerline.size();++i)
{
const auto& a=centerline[i-1];const auto& b=centerline[i];
const double dx=(b[0]-a[0])/1.0e6;
const double dy=(b[1]-a[1])/1.0e6;
const double dz=std::abs(b[2]-a[2])/1.0e6;
const double horizontal=std::hypot(dx,dy);
pathLength+=horizontal;
maxGradeDegrees=std::max(maxGradeDegrees,
@@ -1952,14 +1961,16 @@ int main(int argc,char** argv)
const double width=deck.empty()?0.0:
2.0*deck.front()->halfExtentsMicrometres[1]/1.0e6;
std::printf("[LiminalRoadResolved] vocabulary=%u id=liminal/road-clouds-v2 "
"strate=%d shape=swept_deck_segments deck_segments=%zu supports=%zu "
"strate=%d shape=continuous_swept_deck deck_stamps=%zu centerline_points=%zu supports=%zu "
"path_length_m=%.3f width_m=%.3f grade_max_deg=%.3f "
"placement=free route_keepout=PASS band_clearance=PASS status=%s\n",
resolvedLayout.stampVocabularyVersion,
deck.empty()?-1:deck.front()->strateIndex,deck.size(),supportCount,pathLength,
width,maxGradeDegrees,deck.size()>1&&pathLength>=300.0&&width>=3.0
deck.empty()?-1:deck.front()->strateIndex,deck.size(),centerline.size(),
supportCount,pathLength,width,maxGradeDegrees,
deck.size()==1&&centerline.size()>=2&&pathLength>=300.0&&width>=3.0
&&maxGradeDegrees<=15.0?"PASS":"FAIL");
if(deck.size()<2||pathLength<80.0||width<3.0||maxGradeDegrees>15.0)
if(deck.size()!=1||centerline.size()<2||pathLength<80.0
||width<3.0||maxGradeDegrees>15.0)
{std::fprintf(stderr,"Liminal road resolved outside the walkable road bounds\n");return 2;}
}
if(hasLiminalPillarGrid)
Standalone/Source/StreamBenchmarkPipeline.h
+52 -26
View File
@@ -2981,28 +2981,48 @@ namespace StandaloneStreamBenchmark
constexpr double HalfCapsuleHeightMetres=CapsuleHeightMetres*0.5;
constexpr double SlopeCapsuleClearanceMetres=0.12;
std::vector<std::array<double,3>> roadPath;
roadPath.reserve(deck.size()*4);
std::vector<std::array<double,3>> centerline;
centerline.reserve(deck.size()+1);
bool surfacePathValid=true;
for(std::size_t i=0;i<deck.size();++i)
const bool continuousDeck=deck.size()==1
&&deck.front()->kind
==VoxelForgeCore::ResolvedSdfStampKindV1::fillSweptDeckSegment
&&deck.front()->sweepPathMicrometres.size()>=2;
bool surfacePathValid=continuousDeck;
if(continuousDeck)
{
const auto* segment=deck[i];
if(segment->kind!=VoxelForgeCore::ResolvedSdfStampKindV1::fillSweptDeckSegment)
surfacePathValid=false;
const auto point=[&](std::size_t endpoint)
{return std::array<double,3>{
segment->sweepEndpointsMicrometres[endpoint][0]/1.0e6,
segment->sweepEndpointsMicrometres[endpoint][1]/1.0e6,
segment->sweepEndpointsMicrometres[endpoint][2]/1.0e6};};
const auto a=point(0),b=point(1);
if(i==0)centerline.push_back(a);
else if(std::abs(centerline.back()[0]-a[0])>1.0e-6
||std::abs(centerline.back()[1]-a[1])>1.0e-6
||std::abs(centerline.back()[2]-a[2])>1.0e-6)
surfacePathValid=false;
centerline.push_back(b);
centerline.reserve(deck.front()->sweepPathMicrometres.size());
for(const auto& point:deck.front()->sweepPathMicrometres)
centerline.push_back({point[0]/1.0e6,point[1]/1.0e6,point[2]/1.0e6});
surfacePathValid=surfacePathValid
&&centerline.front()[0]
==deck.front()->sweepEndpointsMicrometres[0][0]/1.0e6
&&centerline.back()[0]
==deck.front()->sweepEndpointsMicrometres[1][0]/1.0e6;
}
else
{
centerline.reserve(deck.size()+1);
surfacePathValid=true;
for(std::size_t i=0;i<deck.size();++i)
{
const auto* segment=deck[i];
if(segment->kind
!=VoxelForgeCore::ResolvedSdfStampKindV1::fillSweptDeckSegment)
surfacePathValid=false;
const auto point=[&](std::size_t endpoint)
{return std::array<double,3>{
segment->sweepEndpointsMicrometres[endpoint][0]/1.0e6,
segment->sweepEndpointsMicrometres[endpoint][1]/1.0e6,
segment->sweepEndpointsMicrometres[endpoint][2]/1.0e6};};
const auto a=point(0),b=point(1);
if(i==0)centerline.push_back(a);
else if(std::abs(centerline.back()[0]-a[0])>1.0e-6
||std::abs(centerline.back()[1]-a[1])>1.0e-6
||std::abs(centerline.back()[2]-a[2])>1.0e-6)
surfacePathValid=false;
centerline.push_back(b);
}
}
roadPath.reserve(centerline.size()*4);
double pathLengthMetres=0.0,maxGradeDegrees=0.0;
std::uint64_t surfaceProbes=0,surfaceMisses=0;
const auto surfaceTopAt=[&](double xMetres,double yMetres,
@@ -3010,11 +3030,18 @@ namespace StandaloneStreamBenchmark
{
++surfaceProbes;
double low=nominalTop-0.25,high=nominalTop+1.0;
if(Shape.densityAt({xMetres/coreMetres,yMetres/coreMetres,
low/coreMetres})>=0.0f
||Shape.densityAt({xMetres/coreMetres,yMetres/coreMetres,
high/coreMetres})<0.0f)
{++surfaceMisses;return false;}
const float lowDensity=Shape.densityAt({xMetres/coreMetres,
yMetres/coreMetres,low/coreMetres});
const float highDensity=Shape.densityAt({xMetres/coreMetres,
yMetres/coreMetres,high/coreMetres});
if(lowDensity>=0.0f||highDensity<0.0f)
{
++surfaceMisses;
std::printf("[LiminalRoadSurfaceProbeMiss] x_m=%.6f y_m=%.6f "
"nominal_top_m=%.6f low_density=%.6f high_density=%.6f\n",
xMetres,yMetres,nominalTop,lowDensity,highDensity);
return false;
}
for(int iteration=0;iteration<20;++iteration)
{
const double middle=(low+high)*0.5;
@@ -3059,8 +3086,7 @@ namespace StandaloneStreamBenchmark
const FWalkAudit roadAudit=auditPlayerPath(Shape,roadPath,
0.125,0.125,1.125,3,0.45);
const double widthMetres=2.0*deck.front()->halfExtentsMicrometres[1]/1.0e6;
passed=std::all_of(deck.begin(),deck.end(),[](const auto* road)
{return road->kind==VoxelForgeCore::ResolvedSdfStampKindV1::fillSweptDeckSegment;})
passed=continuousDeck
&&pathLengthMetres>=300.0&&widthMetres>=3.0
&&maxGradeDegrees<=15.0&&surfacePathValid&&roadAudit.passed;
std::printf("[LiminalRoadWalkAudit] id=liminal/road-clouds-v2 "
Standalone/Source/WorldAssemblyPrototype.h
+10 -20
View File
@@ -707,26 +707,16 @@ namespace StandaloneWorldAssemblyPrototype
requests.push_back(std::move(request));
};
const std::int64_t deckSmoothUm=250000;
const std::int64_t segmentOverlapUm=350000;
for(std::uint32_t i=1;i<path.size();++i)
{
const auto& a=path[i-1];const auto& b=path[i];
const double dx=static_cast<double>(b[0]-a[0]);
const double dy=static_cast<double>(b[1]-a[1]);
const double dz=static_cast<double>(b[2]-a[2]);
const std::int64_t halfLengthUm=static_cast<std::int64_t>(std::ceil(
std::sqrt(dx*dx+dy*dy+dz*dz)*0.5))+segmentOverlapUm;
ResolvedLayoutStampRequestV1 request;
request.stableId=*id+"/deck/"+std::to_string(10000+i-1).substr(1);
request.strateIndex=strateIndex;
request.kind=ResolvedSdfStampKindV1::fillSweptDeckSegment;
request.anchorPositionMicrometres={
(a[0]+b[0])/2,(a[1]+b[1])/2,(a[2]+b[2])/2};
request.sweepEndpointsMicrometres={a,b};
request.halfExtentsMicrometres={halfLengthUm,halfWidthUm,halfThicknessUm};
request.smoothWidthMicrometres=deckSmoothUm;
requests.push_back(std::move(request));
}
ResolvedLayoutStampRequestV1 deck;
deck.stableId=*id+"/deck/000";
deck.strateIndex=strateIndex;
deck.kind=ResolvedSdfStampKindV1::fillSweptDeckSegment;
deck.anchorPositionMicrometres=path[path.size()/2];
deck.sweepEndpointsMicrometres={path.front(),path.back()};
deck.sweepPathMicrometres=path;
deck.halfExtentsMicrometres={500000,halfWidthUm,halfThicknessUm};
deck.smoothWidthMicrometres=deckSmoothUm;
requests.push_back(std::move(deck));
const std::int64_t supportBaseUm=fieldFloorMicrometres-2000000;
const std::int64_t supportRadiusUm=metresToMicrometres(supportRadius);
double distanceSinceSupport=supportSpacing;