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

feat(core): slab + sparse motifs, slice 1 -- flat field, monolith, platform at 0.52 s (L56); research R25

Browse Source 
Motif vocabulary v3: version-1 records keyed by (seed, strate, stable ID) with route keepouts, band
clearance and pairwise spacing. A rounded capped-cylinder monolith (r 1.4 m, 24 m tall) and a rounded-box
plinth, smooth-unioned into a flatField floor with a 0.55 m geometric rounding (measured fillets 0.73-1.17 m).
Exact radial/box interval bounds, a BVH, isTileShapeFree aware (0 brute-force misses, false-proof controls
rejected). Final-field route passes; whole-surface audit covers foot, cap and platform edges. Cold whole
view 0.524 s. Owner world unchanged. fast/medium/full PASS (Clang and GCC).
Research R25 (self-checked): FloatingIslands LOD0 column cache conflicts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
This commit is contained in:
Fr0zkaandClaude Opus 5.5 committed 2026-10-25 07:47:15 +01:00
1 parent aee1487410
commit 4e64b75044
15 files changed
+1560 -12
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Standalone/Core/src/ResolvedLayoutInternal.h
+223 -8
View File
@@ -165,8 +165,11 @@ namespace
{
const auto value=static_cast<std::uint8_t>(kind);
return value>=static_cast<std::uint8_t>(ResolvedSdfStampKindV1::carveEllipsoid)
&&value<=static_cast<std::uint8_t>(ResolvedSdfStampKindV1::fillDais);
&&value<=static_cast<std::uint8_t>(ResolvedSdfStampKindV1::fillPlatform);
}
bool LayoutStampIsMotif(ResolvedSdfStampKindV1 kind)
{return kind==ResolvedSdfStampKindV1::fillMonolith
||kind==ResolvedSdfStampKindV1::fillPlatform;}
double LayoutStampPointSegmentDistance(const std::array<std::int64_t,3>& point,
const std::array<std::int64_t,3>& a,const std::array<std::int64_t,3>& b)
{
@@ -453,7 +456,9 @@ namespace
{
if(stamp.strateIndex!=vein.strateIndex
||(stamp.kind!=ResolvedSdfStampKindV1::fillDais
&&stamp.kind!=ResolvedSdfStampKindV1::fillPillar))continue;
&&stamp.kind!=ResolvedSdfStampKindV1::fillPillar
&&stamp.kind!=ResolvedSdfStampKindV1::fillMonolith
&&stamp.kind!=ResolvedSdfStampKindV1::fillPlatform))continue;
bool overlaps=true;
for(std::size_t axis=0;axis<3;++axis)
overlaps=overlaps&&vein.boundsMinimumMicrometres[axis]
@@ -581,7 +586,13 @@ namespace
<<",\"irregularity_amplitude_um\":"<<stamp.irregularityAmplitudeMicrometres
<<",\"irregularity_wavelength_um\":"<<stamp.irregularityWavelengthMicrometres
<<",\"irregularity_seed\":"<<stamp.irregularitySeed
<<",\"yaw_quarter_turns\":"<<static_cast<unsigned>(stamp.yawQuarterTurns)<<'}';
<<",\"yaw_quarter_turns\":"<<static_cast<unsigned>(stamp.yawQuarterTurns);
if(s.stampVocabularyVersion>=ResolvedLayoutStampVocabularyVersionV3)
out<<",\"rounding_radius_um\":"<<stamp.roundingRadiusMicrometres
<<",\"minimum_spacing_um\":"<<stamp.minimumSpacingMicrometres
<<",\"attachment_policy\":"<<static_cast<unsigned>(stamp.attachmentPolicy)
<<",\"floor_um\":"<<stamp.floorMicrometres;
out<<'}';
}
out<<']';
}
@@ -1107,8 +1118,9 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
add("stamp_vocabulary_version","stamp vocabulary version is set without any stamp records");
}
else if(stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV1
&&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV2)
add("stamp_vocabulary_version","resolved stamps require supported vocabulary version 1 or 2");
&&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV2
&&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV3)
add("stamp_vocabulary_version","resolved stamps require supported vocabulary version 1, 2 or 3");
std::vector<std::string> stampIds;
for(const auto& stamp:stamps)
{
@@ -1116,7 +1128,9 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
||std::find(stampIds.begin(),stampIds.end(),stamp.stableId)!=stampIds.end())
add("stamp_identity","stamp has an empty or duplicate stable identity");
else stampIds.push_back(stamp.stableId);
if(!LayoutStampKindValid(stamp.kind)||stamp.yawQuarterTurns>3)
const bool motif=LayoutStampIsMotif(stamp.kind);
if(!LayoutStampKindValid(stamp.kind)||stamp.yawQuarterTurns>3
||(motif&&stampVocabularyVersion<ResolvedLayoutStampVocabularyVersionV3))
add("stamp_kind","stamp has an unsupported kind or orientation");
bool validExtents=true;
for(const auto extent:stamp.halfExtentsMicrometres)
@@ -1130,8 +1144,33 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
||(stamp.irregularityAmplitudeMicrometres>0
&&stamp.irregularityWavelengthMicrometres<=0))
add("stamp_parameters",stamp.stableId+" has invalid or unbounded geometry parameters");
const std::int64_t pad=stamp.smoothWidthMicrometres
+stamp.irregularityAmplitudeMicrometres;
if(motif)
{
const auto minimumExtent=*std::min_element(stamp.halfExtentsMicrometres.begin(),
stamp.halfExtentsMicrometres.end());
const bool monolith=stamp.kind==ResolvedSdfStampKindV1::fillMonolith;
const bool shapeValid=monolith
?stamp.halfExtentsMicrometres[0]==stamp.halfExtentsMicrometres[1]
&&stamp.halfExtentsMicrometres[0]>=800000
&&stamp.halfExtentsMicrometres[0]<=2000000
&&stamp.halfExtentsMicrometres[2]>=6000000
&&stamp.halfExtentsMicrometres[2]<=16000000
:stamp.halfExtentsMicrometres[0]>=1000000
&&stamp.halfExtentsMicrometres[1]>=1000000;
if(stampVocabularyVersion<ResolvedLayoutStampVocabularyVersionV3
||stamp.roundingRadiusMicrometres<500000
||stamp.roundingRadiusMicrometres>minimumExtent
||stamp.minimumSpacingMicrometres<0
||stamp.minimumSpacingMicrometres>100000000
||stamp.attachmentPolicy!=1
||stamp.positionMicrometres[2]
!=stamp.floorMicrometres+stamp.halfExtentsMicrometres[2]
||!shapeValid||stamp.irregularityAmplitudeMicrometres!=0)
add("stamp_motif_parameters",stamp.stableId+" has invalid kind, size, fillet or floor attachment");
}
const std::int64_t pad=motif
?(stamp.smoothWidthMicrometres+5)/6+stamp.irregularityAmplitudeMicrometres
:stamp.smoothWidthMicrometres+stamp.irregularityAmplitudeMicrometres;
const std::array<std::int64_t,3> extents={
stamp.halfExtentsMicrometres[stamp.yawQuarterTurns%2?1:0]+pad,
stamp.halfExtentsMicrometres[stamp.yawQuarterTurns%2?0:1]+pad,
@@ -1146,6 +1185,35 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
if(!LayoutStampSafe(*this,stamp,&safetyReason))
add("stamp_placement",stamp.stableId+" is unsafe: "+safetyReason);
}
if(stampVocabularyVersion>=ResolvedLayoutStampVocabularyVersionV3)
{
for(std::size_t i=0;i<stamps.size();++i)
{
if(!LayoutStampIsMotif(stamps[i].kind))continue;
for(std::size_t j=0;j<i;++j)
{
if(!LayoutStampIsMotif(stamps[j].kind)
||stamps[i].strateIndex!=stamps[j].strateIndex)continue;
double gapSquared=0.0;
for(std::size_t axis=0;axis<3;++axis)
{
const auto gap=stamps[i].boundsMinimumMicrometres[axis]
>stamps[j].boundsMaximumMicrometres[axis]
?stamps[i].boundsMinimumMicrometres[axis]
-stamps[j].boundsMaximumMicrometres[axis]
:stamps[j].boundsMinimumMicrometres[axis]
>stamps[i].boundsMaximumMicrometres[axis]
?stamps[j].boundsMinimumMicrometres[axis]
-stamps[i].boundsMaximumMicrometres[axis]:0;
gapSquared+=static_cast<double>(gap)*gap;
}
const auto required=std::max(stamps[i].minimumSpacingMicrometres,
stamps[j].minimumSpacingMicrometres);
if(gapSquared<static_cast<double>(required)*required)
add("stamp_motif_spacing",stamps[i].stableId+" is too close to "+stamps[j].stableId);
}
}
}
if(cavernRooms.empty()&&cavernEdges.empty())
{
if(cavernGraphVocabularyVersion!=0)
@@ -1393,6 +1461,10 @@ std::optional<ResolvedLayoutSnapshotV3> ResolvedLayoutSnapshotV3::FromJson(
stamp.smoothWidthMicrometres=LayoutInt(v,"smooth_width_um");
stamp.irregularityAmplitudeMicrometres=LayoutInt(v,"irregularity_amplitude_um");
stamp.irregularityWavelengthMicrometres=LayoutInt(v,"irregularity_wavelength_um");
stamp.roundingRadiusMicrometres=LayoutInt(v,"rounding_radius_um");
stamp.minimumSpacingMicrometres=LayoutInt(v,"minimum_spacing_um");
stamp.attachmentPolicy=static_cast<std::uint8_t>(LayoutInt(v,"attachment_policy"));
stamp.floorMicrometres=LayoutInt(v,"floor_um");
stamp.irregularitySeed=static_cast<std::uint64_t>(LayoutInt(v,"irregularity_seed"));
stamp.yawQuarterTurns=static_cast<std::uint8_t>(LayoutInt(v,"yaw_quarter_turns"));
s.stamps.push_back(std::move(stamp));
@@ -1607,6 +1679,149 @@ bool ResolveResolvedLayoutStampsV2(ResolvedLayoutSnapshotV3& layout,std::int32_t
layout=std::move(candidate);return true;
}
bool ResolveResolvedLayoutStampsV3(ResolvedLayoutSnapshotV3& layout,std::int32_t seed,
std::span<const ResolvedLayoutStampRequestV1> requests,std::string& error)
{
error.clear();
if(requests.empty())
{
ResolvedLayoutSnapshotV3 candidate=layout;
candidate.stampVocabularyVersion=0;candidate.stamps.clear();
if(!candidate.finalize(error))return false;
layout=std::move(candidate);return true;
}
std::vector<ResolvedLayoutStampRequestV1> ordered(requests.begin(),requests.end());
std::sort(ordered.begin(),ordered.end(),[](const auto& a,const auto& b)
{return a.stableId<b.stableId;});
ResolvedLayoutSnapshotV3 candidate=layout;
candidate.stampVocabularyVersion=ResolvedLayoutStampVocabularyVersionV3;
candidate.stamps.clear();candidate.stamps.reserve(ordered.size());
for(std::size_t requestIndex=0;requestIndex<ordered.size();++requestIndex)
{
const auto& request=ordered[requestIndex];
if(request.stableId.empty()||(requestIndex>0
&&ordered[requestIndex-1].stableId==request.stableId))
{error="motif requests require non-empty unique stable IDs";return false;}
if(!LayoutStampIsMotif(request.kind)||request.yawQuarterTurns>3
||request.placementRadiusMicrometres<0
||request.placementRadiusMicrometres>100000000
||request.smoothWidthMicrometres<0||request.smoothWidthMicrometres>10000000
||request.irregularityAmplitudeMicrometres!=0
||request.irregularityWavelengthMicrometres<0
||request.irregularityWavelengthMicrometres>100000000
||request.roundingRadiusMicrometres<500000
||request.minimumSpacingMicrometres<0
||request.minimumSpacingMicrometres>100000000
||request.attachmentPolicy!=1)
{error="motif request "+request.stableId+" has invalid or unbounded parameters";return false;}
if(std::any_of(request.halfExtentsMicrometres.begin(),request.halfExtentsMicrometres.end(),
[](std::int64_t extent){return extent<500000||extent>100000000;}))
{error="motif request "+request.stableId+" has an extent outside 0.5..100 m";return false;}
const bool monolith=request.kind==ResolvedSdfStampKindV1::fillMonolith;
const auto minimumExtent=*std::min_element(request.halfExtentsMicrometres.begin(),
request.halfExtentsMicrometres.end());
const bool dimensionsValid=monolith
?request.halfExtentsMicrometres[0]==request.halfExtentsMicrometres[1]
&&request.halfExtentsMicrometres[0]>=800000
&&request.halfExtentsMicrometres[0]<=2000000
&&request.halfExtentsMicrometres[2]>=6000000
&&request.halfExtentsMicrometres[2]<=16000000
:request.halfExtentsMicrometres[0]>=1000000
&&request.halfExtentsMicrometres[1]>=1000000;
if(!dimensionsValid||request.roundingRadiusMicrometres>minimumExtent)
{error="motif request "+request.stableId+" has a shape size outside its authored family";return false;}
const auto stratum=std::find_if(candidate.strates.begin(),candidate.strates.end(),
[&](const auto& value){return value.strateIndex==request.strateIndex;});
if(stratum==candidate.strates.end())
{error="motif request "+request.stableId+" names an unknown strate";return false;}
for(const auto coordinate:request.anchorPositionMicrometres)
if(coordinate<-1000000000000ll||coordinate>1000000000000ll)
{error="motif request "+request.stableId+" has an unbounded anchor";return false;}
if(request.floorMicrometres<-1000000000000ll
||request.floorMicrometres>1000000000000ll)
{error="motif request "+request.stableId+" has an unbounded floor anchor";return false;}
const std::uint64_t baseSeed=LayoutStampSeed(seed,request.strateIndex,request.stableId)
&0x001fffffffffffffull;
std::uint64_t state=baseSeed;
const auto randomOffset=[&](std::uint64_t bits)
{
const std::uint64_t span=static_cast<std::uint64_t>(
request.placementRadiusMicrometres)*2+1;
return request.placementRadiusMicrometres==0?std::int64_t{0}
:static_cast<std::int64_t>(bits%span)-request.placementRadiusMicrometres;
};
bool placed=false;
const std::uint32_t attempts=request.placementRadiusMicrometres==0?1u:512u;
for(std::uint32_t attempt=0;attempt<attempts;++attempt)
{
ResolvedLayoutStampV1 stamp;stamp.stableId=request.stableId;
stamp.strateIndex=request.strateIndex;stamp.kind=request.kind;
stamp.halfExtentsMicrometres=request.halfExtentsMicrometres;
stamp.smoothWidthMicrometres=request.smoothWidthMicrometres;
stamp.irregularityAmplitudeMicrometres=0;
stamp.irregularityWavelengthMicrometres=request.irregularityWavelengthMicrometres;
stamp.roundingRadiusMicrometres=request.roundingRadiusMicrometres;
stamp.minimumSpacingMicrometres=request.minimumSpacingMicrometres;
stamp.attachmentPolicy=request.attachmentPolicy;
stamp.floorMicrometres=request.floorMicrometres;
stamp.irregularitySeed=baseSeed;stamp.yawQuarterTurns=request.yawQuarterTurns;
const std::array<std::int64_t,2> offset={
randomOffset(LayoutStampNext(state)),randomOffset(LayoutStampNext(state))};
if(request.placementRadiusMicrometres>0)
{
const long double radius=request.placementRadiusMicrometres;
const long double distanceSquared=static_cast<long double>(offset[0])*offset[0]
+static_cast<long double>(offset[1])*offset[1];
if(distanceSquared>radius*radius)continue;
}
stamp.positionMicrometres={request.anchorPositionMicrometres[0]+offset[0],
request.anchorPositionMicrometres[1]+offset[1],
request.floorMicrometres+request.halfExtentsMicrometres[2]};
const std::int64_t pad=(stamp.smoothWidthMicrometres+5)/6;
const std::array<std::int64_t,3> extents={
stamp.halfExtentsMicrometres[stamp.yawQuarterTurns%2?1:0]+pad,
stamp.halfExtentsMicrometres[stamp.yawQuarterTurns%2?0:1]+pad,
stamp.halfExtentsMicrometres[2]+pad};
for(std::size_t axis=0;axis<3;++axis)
{
stamp.boundsMinimumMicrometres[axis]=stamp.positionMicrometres[axis]-extents[axis];
stamp.boundsMaximumMicrometres[axis]=stamp.positionMicrometres[axis]+extents[axis];
}
if(!LayoutStampSafe(candidate,stamp))continue;
bool spaced=true;
for(const auto& prior:candidate.stamps)
{
if(!LayoutStampIsMotif(prior.kind)||prior.strateIndex!=stamp.strateIndex)continue;
double gapSquared=0.0;
for(std::size_t axis=0;axis<3;++axis)
{
const auto gap=stamp.boundsMinimumMicrometres[axis]
>prior.boundsMaximumMicrometres[axis]
?stamp.boundsMinimumMicrometres[axis]-prior.boundsMaximumMicrometres[axis]
:prior.boundsMinimumMicrometres[axis]
>stamp.boundsMaximumMicrometres[axis]
?prior.boundsMinimumMicrometres[axis]-stamp.boundsMaximumMicrometres[axis]:0;
gapSquared+=static_cast<double>(gap)*gap;
}
const auto required=std::max(stamp.minimumSpacingMicrometres,
prior.minimumSpacingMicrometres);
if(gapSquared<static_cast<double>(required)*required)
{spaced=false;break;}
}
if(!spaced)continue;
candidate.stamps.push_back(std::move(stamp));placed=true;break;
}
if(!placed)
{error="motif request "+request.stableId+" has no deterministic route-, band- and spacing-safe placement";return false;}
}
if(!candidate.finalize(error))return false;
std::vector<ResolvedLayoutIssueV2> issues;std::string strictError;
if(!candidate.validate(ResolvedLayoutValidationModeV3::strict,issues,strictError))
{error="strict stamp vocabulary-3 validation failed: "+strictError;return false;}
layout=std::move(candidate);return true;
}
bool ResolveResolvedCavernGraphV1(ResolvedLayoutSnapshotV3& layout,std::int32_t seed,
std::span<const ResolvedCavernRoomV1> rooms,
std::span<const ResolvedCavernEdgeV1> edges,std::string& error)