c993e6e877c5306ea8ecfd94018bd93b46a534cd
103 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Fr0zka
|
c993e6e877 |
docs(opstack): handoff heads with the four-things-on-one-build table
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
eaa44bf0c0 |
fix(opstack): two cell-sweep pads assumed MinRadius <= MaxRadius; a third already didn't
Second defect from the full 28-op EffectOverBox audit. Three ops roll a radius as Lerp(MinRadius, MaxRadius, hash01), which lands in [min(A,B), max(A,B)] -- Lerp does not require A <= B. Their EffectOverBox sweeps lattice cells padded by the largest radius a cell could hold, so a pad below the true maximum means the cells are never examined and the op reports Identity for a box its own Eval will fill or carve: no geometry, no collision. FGridColumnMod ~1086 Max(MaxRadius, 0) exposed FShaftFieldSource ~1436 Max(ShaftMaxRadius, ConnectorRadius) exposed FIslandBlobSource ~1803 Max(IslandMinRadius, IslandMaxRadius) already correct The third one is the argument: the concern was met and guarded once in this same file, and the other two shipped without it. Fixed with FMath::Max3, a spelling already used here (~2481) and in VoxelCaveMorphology.cpp. Shipped defaults are ordered correctly (2/5, 2/7, 5/11), so this is a NO-OP at defaults -- that is its acceptance signal, and any moved number means the diff did more than intended. It needs a mis-ordered asset value, which nothing prevents: ClampMin is a per-property floor and UE cannot express "<= that other property". ColumnMinRadius is also settable per-room via UVoxelTerrainOpDefinition. Deliberately NOT fixed by normalising the params: swapping the Lerp endpoints maps the same hash to a different radius, changing geometry and breaking the eight equivalence tests. Only the bound becomes conservative; Eval is byte- identical -- verified, no Eval/Roll/GetCells line in the diff. Also audited and found sound (recorded so they are not re-chased): FPassageCarveOp and the passage bounding sphere, FOriginSpineOp, FBoundarySealOp, FShaftLedgeMod, FCaveArchMod, FDomeMod. Not built -- Jahni builds. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
108982d135 |
docs(opstack): the proved-bound rule now names VF_PerlinAbsBound and the FBM normalisation
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
7dbdf51b44 |
fix(opstack): three ExtraReach box verdicts used sup|FBM| = 1.0; the proved bound is 1.5
CORRECTNESS on a box verdict, not perf. This file derives |Perlin3D| <= 1.5
rigorously, exposes it as PerlinAbsBound, uses it for the tunnel warp, and says
outright that the header's "~[-1,1]" is an observation and that a box verdict
resting on one is a hole. Three ExtraReach formulas in the same file assumed
sup|FBM| <= 1.0 -- and VoxelNoise::FBM normalises (Total / MaxValue), so
sup|FBM| = sup|Perlin3D| exactly. The bound was wrong by 1.5x.
At shipped defaults, soundness needed B <= 1.27 (VerticalShafts, Rough 3.0) and
B <= 1.40 (Maze, Rough 2.0); both are violated at B = 1.5. Break-even roughness
is 1.6. FloatingIslands survives only because its SDFBlendRadius is 5 -- sound
by parameter luck, not construction.
Nothing in the running game was affected (no strate has bUseOperatorStack
ticked) and the empirical Perlin sup ~1.0-1.1 is why nothing surfaced. But the
tile scans SAMPLE, and for shafts they sampled a source that proved zero tiles
until
|
||
|
Fr0zka
|
b5294b2d5b |
docs: close C2, sharpen the column-memo prediction, reassess REVIEW_FINDINGS
Reading session -- no build available, so: verify things instead of writing code. - Cross-checked the eight stat declarations against their definitions and use sites. Identical. The one compile risk I had only eyeballed is now retired. - REVIEW_FINDINGS: the GetDensityWithParams and BuildChunkCache splits are now counter-productive rather than optional -- the op stack is replacing the first, and FRoomGraphSource deliberately CALLS the second so a restructure forks what was kept unforked. The two passage enums are not duplicates and are UMETA-serialised into authored assets; merging them rewrites content for tidiness. Judged: leave, and close the item. - CODEX-TASK-002's acceptance said "20-30% of lookups", a guess wearing a number. Replaced with arithmetic from the real grid: 1225 columns/tile over 35 Z planes, load factor 0.299, ~317 colliding columns, ~12000 vs 1225 computations = ~9.8x. Plus the reading rule that matters -- the overhang and cliff mods re-query the same XY and add HITS only, so compare the ratio of the two hypotheses, not an absolute percentage. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
b426cfcb0d |
docs(audit): C2 is FULLY closed -- the live-edit half was fixed too
Was about to spec a Codex fix for OC_Chunk / BM_Chunk / FChunkBiomeCache, which three docs still list as open. Checked the sites first. All of them already carry a layout-version guard: CP_Chunk -> CP_Version OC_Chunk -> OC_Version BM_Chunk -> BM_Version TC_BiomeCache -> TC_SeenVersion FChunkBiomeCache::Invalidate() exists precisely because the validity box says nothing about the FBiomeContext its cells were classified against, and all four thread_local instances call it on a version change. The only other two instances in the tree (VoxelContentManager ~445, the height-stack test) are function-local, constructed per task, so staleness is impossible there. Seventh time in this project a confident premise reversed on reading. It cost a doc edit instead of a Codex run and a build cycle. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
eb317d9933 |
feat(stats): stat VoxelForge -- make tile skipping and the column memo observable
The plugin had ZERO stat counters, so every claim this refactor makes was harness-only: "skipped correctly" and "skipped nothing" render identically. CODEX-TASK-001 and -002, executed by Codex (gpt-5.6-luna xhigh), reviewed against the source. Eight DWORD counters in a new stat group: GenerateTileResult -- TilesClassified / SkippedAllSolid / SkippedAllAir / Meshed ClassifyTile bAnyCave exit -- TilesOpStackSolid / TilesOpStackAir FSurfaceColumnSource::GetColumn -- ColumnMemoHit / ColumnMemoMiss The op-stack counters are separate from the lumped skip counters on purpose: ClassifyTile also proves AllSolid on its hand-written bedrock-gap path with no strate opted in, so the lumped number cannot show a before/after. The op-stack pair is zero BY CONSTRUCTION until a strate ticks the flag. GetColumn is instrumented and deliberately NOT fixed -- the instrument and the fix in one build would make each other unreadable. Verified against UE_5.7 Stats.h rather than assumed (first stats use in this plugin, no in-repo precedent): all four macro arities, and INC_DWORD_STAT -> FThreadStats::AddMessage, so the worker-thread safety both sites need holds by mechanism. Not built -- Jahni builds. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
7909c4f2ca |
docs(opstack): handoff -- 001 chains into 002, and PERF is now aimed
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
7313201e91 |
docs: spec CODEX-TASK-002 (column-memo thrash) and aim the PERF work
Three orchestration findings on the parked PERF item, none measured yet: 1. The perf A/B needs no new code -- two Insights traces on a deterministic world are a clean before/after. But tile skipping changes how many times GenerateMesh runs, so totals conflate "cheaper per tile" with "fewer tiles". TilesMeshed from task 001 is the denominator. 001 is therefore a PREREQUISITE for the perf work, not a parallel item as the handoff had it. 2. The suspects don't share an archetype: SurfaceWorld is the column memo, TunnelNetwork is 19 virtual calls per voxel (16 + 3 structural post). One lumped number can't be acted on -- measure one strate at a time. 3. GetColumn is a direct-mapped hashed table where GSurfColCache is a direct-indexed box, and the mesher pre-samples Z-OUTERMOST (verified, VoxelMarchingCubesMesher.cpp ~226) so every column is revisited ~34x per tile. The table's sizing comment reasons about fullness; a direct-mapped table evicts on collision. At load factor 0.28 that is still ~25% of columns recomputing the full height stack every Z plane -- derived ~9x. Task 002 measures that and fixes nothing, so the instrument and the fix cannot land in the same build and make each other unreadable. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
57002b35cf |
docs(opstack): log the CODEX-TASK-001 acceptance-bar correction
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
6bd5589d53 |
docs(codex-001): the lumped AllSolid counter cannot prove T1.d -- add the op-stack site
Reviewing the spec against ClassifyTile reversed its acceptance bar. The function reaches a non-Mixed verdict two independent ways: the hand-written path (a bedrock gap sets bCanAir=false, VoxelGenerator.cpp ~2835, and the tile resolves AllSolid) and the operator-stack path (the bAnyCave block). The first fires with NO strate opted in, so the spec's baseline -- "TilesSkippedAllSolid stays 0 underground" -- was never going to hold, and the before/after would have been unreadable. Adds site B at the bAnyCave exit (~3009) with TilesOpStackSolid / TilesOpStackAir. Those are zero BY CONSTRUCTION without an opted-in strate, since the branch returns Mixed at the UsesOperatorStackForChunk gate -- a stronger baseline than the one it replaces. Deliverable is now: tick the box, TilesOpStackSolid goes non-zero. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
251a1288e0 |
docs: spec CODEX-TASK-001 (tile-skip stats) and refresh the handoff for the Codex tandem
Jahni built a world and said "I don't know if it dropped any meshing? but it
looks alright by the eye." That sentence is the honest state of this refactor:
everything proved so far was proved in an automation harness on 40 sampled
tiles, and in the running game tile-skipping is unobservable.
grep INC_DWORD_STAT over Source/ returns nothing -- the plugin has zero stat
counters -- and "skipped correctly" renders identically to "skipped nothing", so
no visual check can separate them. The tests got the "coverage is a number, not
a boolean" discipline this session; the game never did.
CODEX-TASK-001-tile-skip-stats.md specs a stat VoxelForge group with
TilesClassified / TilesSkippedAllSolid / TilesSkippedAllAir / TilesMeshed. Solid
and air are split deliberately: cave archetypes prove AllSolid, so that counter
is the one that says whether the op-stack work did anything real. Its deliverable
is the before/after that constitutes the PRODUCTION proof of T1.d, which does not
exist today.
The spec carries the invariants rather than just the task, which is the point of
a spec here: bTrivialEmpty decides whether a tile has COLLISION, the five-clause
gate is load-bearing, and GenerateTileResult runs on worker threads -- so a plain
static int32++ is a data race while INC_DWORD_STAT is not.
Handoff updated: a "How we work now" section (Codex Model Luna xHigh writes most
code, Claude orchestrates -- hand over the INVARIANT, review against the code and
not the description), first actions split into the Codex task and the pending
|
||
|
Fr0zka
|
e4d1fdd7ea |
docs(opstack): experimental is pushed and tracked -- correct the flat "never push" rule
The rule said "Never push" without qualification, which was true while experimental existed only locally and became misleading the moment it did not: a future session would read it and let origin/experimental drift. Now: push experimental freely (tracked since 2026-07-29), never push main, which stays pinned at the known-good commit. Both statements of the rule are updated (OPSTACK-HANDOFF.md and OPSTACK-PROMPT.md's crash-safe discipline). Also added at both sites, because it is the failure mode this creates: a pushed commit is NOT a "verified green" marker. This branch carries unbuilt work by design, so OPSTACK-PROGRESS.md remains the only record of what was actually built and measured, and the remote records only what was written. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
41ba3c34a9 |
docs(opstack): rewrite the handoff for the T1.d-delivered state
The old handoff's "first action" (confirm the Underwater coverage number) and its
"one task everything is waiting on" (make FRoomGraphSource::EffectOverBox answer
spatially) are both done, so most of it was actively misleading.
What it says now:
- T1.d is real and measured: 11 of 40 tiles proved AllSolid at production
defaults, 14641 voxels brute-forced, 0 violations; dense fixture correctly 0.
- A boxed invariant near the top, because it is the most dangerous thing in the
current code: Identity from the room source means Sdf >= T, not FLT_MAX, and
any new Sdf consumer with a bigger threshold silently produces tiles with no
geometry and no collision.
- First action is now "build
|
||
|
Fr0zka
|
e002bd4e2e |
feat(opstack): VerticalShafts' connector branch never tested a connector -- test the real capsules
Jahni's call: bank T1.d at 11/40 and take VerticalShafts rather than squeeze the Perlin sup. Right call -- a clearly-scoped defect with no hole-risk maths, on an archetype that was getting nothing. The defect is stated in its own comment. FShaftFieldSource::EffectOverBox ended with a "connectors" branch that never looks at a connector: it returns CarveOnly because a shaft EXISTS within Spacing*1.6 + Pad. At ShaftSpacing 55 and ShaftDensity 0.6 that box spans ~4x4 cells and ~10 shafts, so the condition is true essentially everywhere -- exactly the reported 0 proved of 60. Conservative, never wrong, completely sterile; the same shape as the worm's unconditional CarveOnly one archetype over. It now rebuilds the connectors the way GetCells does and tests the real capsule. Two things had to be right and both were read in the source rather than assumed: - The enumeration is a superset. Eval reads connectors from the 3x3 of ITS query's cell, so any pair visible from a point in the box has both shafts in the 3x3 of some cell the box touches, i.e. in [box cells] +- 1 -- the range swept here. Pairs no query ever sees may be produced: extra CarveOnly, never a hole. - The pair order matches, so the hash matches. VoxelHash::Pair is fed in insertion order and GetCells inserts over (dy, dx), row-major; this sweeps (cy, cx), and row-major order restricted to a sub-grid preserves the relative order of two cells. So the same pair gets the same hash WITHOUT assuming Pair() is symmetric -- which was never verified and now need not be. The capsule test splits the axes because a connector is HORIZONTAL at height Zc: Z is exact, XY is point-to-segment from the box centre minus the XY half diagonal. Tighter than the 3-D half-diagonal the tunnel version had to settle for. Also the same sampler trap, caught before the build this time: tile XY was drawn from +-48 voxels against ShaftSpacing 55 -- under one period of the pattern, identical in kind to the +-32-vs-80 bug that cost the tunnel test three runs. Widened to +-440, and the report prints its own extent in units of ShaftSpacing. The safety net was already there and is untouched: this test brute-forces the full lattice of every proved tile, both hypotheses, and AddErrors on the first violation. If the superset or hash-order argument is wrong, the assertion fails rather than a player falling through the floor. Unbuilt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
861dc8e109 |
docs(opstack): WARP SHARE measured -- half the blocking is the box; plus two corrections
The instrument landed on its first run. At production defaults, rooms reaching go 0.9 -> 0.4 and tunnels 2.4 -> 1.1 when the warp dilation is set to zero: more than half of all remaining blocking is the query box rather than cave geometry. Hypothesis confirmed, and the number is permanent output now. CORRECTION 1. Last entry I claimed BuildChunkCache's Expansion = CaveWarpStrength + 2 means "the whole plugin bets on |Perlin3D| <= 0.8", and used it to argue 2.0 was needlessly conservative. False. Six lines further down, bNeedRebuild tests WarpedX < CachedSMinX || WarpedX > CachedSMaxX -- the cache REBUILDS when the warped query leaves the box, so that expansion is a rebuild-frequency heuristic and nothing bets on 0.8. The 2.0 -> 1.5 change stands on its own derivation. Sixth premise this refactor that reversed on checking, and I asserted this one in the same entry where I diagnosed the habit. CORRECTION 2 / NEGATIVE RESULT. The obvious next move -- evaluate the warp at the box centre, SHIFT the box, dilate only by the variation across it -- does not pay here, worked out before writing it. A rigorous per-axis Lipschitz bound for this Perlin3D is |dV/dfx| <= 4*1.875 + 1 = 8.5 per unit cell (fade derivative times the spread of GradDot, plus GradDot's own linear term, u and v being distinct axes). The half-box is 0.206 in noise units, so the local variation bound is 1.75 against a GLOBAL range bound of 1.5. The local bound is worse than the global one. Recorded so nobody spends a build rediscovering it. That leaves one route for the warp term: tightening the sup of |Perlin3D| from the proved 1.5 toward its apparent true value ~1.0-1.1, worth ~27% of the dilation. Spot-checking a grid is not a proof, and a sup proved wrong is a tile with no geometry and no collision -- so that is a judgement call about appetite, not a technical unknown. State: T1.d delivered and verified. 11 of 40 tiles (27.5%) proved AllSolid at production defaults, 14641 voxels brute-forced, 0 violations. The dense fixture correctly proves nothing. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
b2938d38f1 |
fix(opstack): the warp bound was the dominant term all along -- 2.0 -> 1.5, and MEASURE it
Jahni asked whether I was in a loop. I was, and re-reading the original found it
in one line.
PerlinAbsBound was set to 2.0 in the first commit of the spatial EffectOverBox
and never revisited. The dilation is CaveWarpStrength * VOXEL_NOISE_SCALE *
PerlinAbsBound, and CaveWarpStrength is 8.0 by default:
8 * 1.25 * 2.0 = 20 voxels, applied +/- on every axis
tile 10 voxels -> query box 50 per side -> 125x the tile volume
So the tunnel test I called "an order of magnitude tighter" actually needed
DistToAxis >= 78 against a cull rejecting at ~107. 27% tighter, not 10x -- and
the run said so: tunnels reaching went 78.0 -> 58.5, a 25% cut. The instrument
was right and I credited the tunnels.
Four rounds -- worm, columns, sampler, tunnel disjunction -- each individually
correct, every one of them tightening around a term nobody had measured. I kept
instrumenting what I had just changed and never instrumented what I had assumed.
What re-reading showed: BuildChunkCache is called everywhere with
Expansion = CaveWarpStrength + 2.0f, which is only correct if |Perlin3D| <= 0.8.
The whole plugin has always bet on 0.8. I picked 2.0 -- 2.5x more conservative
than the assumption the cache's own correctness already rests on.
The corrected bound is derived, not guessed. GradDot returns +-u +-v with u and
v two DISTINCT components (checked on all four hash branches). Splitting the
eight corners by i gives, per axis, sum w*|dx| = (1-su)*fx + su*(1-fx) <= 0.5
(max at fx = 0.5). Hence |Perlin3D| <= S_x + S_y + S_z <= 1.5, with no case
analysis on the hashes. Dilation 20 -> 15.
And the instrument that should have existed from the start: EffectOverBox now
also runs every room/tunnel test with the warp dilation set to ZERO and reports
both, so Hit* - Hit*NoWarp is exactly the blocking caused by my box rather than
by geometry. The report says, in the output, that if that gap dominates the next
move is the warp bound and not the primitives.
Separately: the diagnostics had turned into narrative, printing hardcoded numbers
from previous runs next to live ones ("32 of 34 tiles vs 21 for rooms" while the
live figures said 21 of 28). Unreadable, and I wrote all of it. Diagnostics now
report THIS run; the history stays in OPSTACK-PROGRESS.
Unbuilt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
9733179723 |
feat(opstack): tunnels get a threshold test -- T1.d is measured at 6 of 40 tiles, 0 violations
THE PRIZE LANDED. At production defaults: 6 of 40 tiles proved AllSolid, 7986 voxels brute-forced, 0 violations. 15% of tiles skip GenerateMesh entirely, one BuildChunkCache traded against 30000+ density evaluations each, and not one verdict is asserted -- every voxel was re-evaluated and came back on the claimed side. The dense fixture still reports 0, exactly as the arithmetic said it must, so this is a measurement of production rather than of a widened test. The breakdown finally isolated the tunnels: of 34 unproved tiles, 32 were blocked by a tunnel and 21 by a room, so >=13 were tunnel-only. That is what justified the deferred disjunction, and why it was deferred rather than guessed. A primitive no longer matters if it misses its cull OR its own SDF stays >= T+K over the box. Each branch wins on a different class, by calculation: for rooms the cull (Rmax+3K) is tighter than the threshold (Rmax+T+K), so rooms keep the cull alone; for tunnels the cull is a capsule BOUNDING SPHERE, radius ~107 for a 200-long tube of radius 7, against a true segment distance. Order of magnitude. The bound is exact, not cautious. TaperedCapsule was read, not assumed -- Dist(P, ClosestOnSegment) - Lerp(Ra,Rb,t) -- so SDF >= dist(P,segment) - max(Ra,Rb); and dist(box,segment) >= dist(centre,segment) - half-diagonal by triangle inequality. VF_DistPointSegment is written locally rather than taken from FMath: five lines, and "I think that function does that" is not good enough under a correctness bound. Identity CHANGED MEANING, from "Sdf stays FLT_MAX" to "Sdf >= T" with T = max(3*SDFBlendRadius, WormNetworkRange). Sound only because all three consumers of the SDF channel were read one by one: FSdfConvertOp's Blend is MakeSdfCarve(P.SDFBlendRadius, ...) => K; the twelve modifiers gate at 3K; FWormFieldSource at WormNetworkRange. Plus the one that could have bitten -- FCaveTerraceMod re-probes the SDF at Z+-1, OUTSIDE the box, but its gate is line 13 and the probes are lines 28-29, so a gate false everywhere never emits one. ANY NEW CONSUMER OF THE Sdf CHANNEL MUST HAVE A THRESHOLD <= T OR JOIN THAT MAX, or it gets tiles with no geometry and no collision. Written at the site. Why -K suffices for any N: SmoothMin's penalty is exactly zero once |A-B| >= K, so the running minimum saturates at K below the smallest term and cannot descend further. Sdf >= min_i(SDF_i) - K for ANY number of primitives, not - N*K/6 -- without which the slack would scale with the ~88 tunnels and be worthless. Unbuilt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
87a0b996ec |
test(opstack): measure the box verdict on BOTH densities -- the fixture cannot prove a tile
The widened sampler worked: 39 of 40 tiles now land clear of the (0,0) spine.
The verdict did not move -- rooms still hit 40 of 40. By my own pre-registered
rule that means the room-lattice model was wrong, and it was, for a reason the
report had been printing at me for three runs: "= 7.6 x RoomSpacing 42".
RoomSpacing is 42 here, not the 80 I did the arithmetic with. I read the
UPROPERTY default out of the header instead of the fixture that overrides it.
Fifth premise this refactor that reversed on being checked, and the plainest:
the number was on screen.
EnableTunnelFeatures densifies on purpose -- RoomSpacing 80 -> 42, RoomDensity
0.35 -> 0.85 -- because at the defaults only 1.1% of samples were in open cave
and the equivalence compared solid rock to solid rock. That densification is what
makes check 1 mean anything, and it is exactly antagonistic to provability:
room cull radius = max(R*1.5, R*HeightRatio) + 3*SDFBlendRadius
= 1.5R + 12 for R in [10,30] => 27..57, mean ~42
lattice spacing = 42 at 85% occupancy
The mean cull radius equals the lattice spacing, so cull spheres cover that world
~3.6x over and NO box can be outside all of them. "6.3 of 8.3 rooms reach" is not
a loose test, it is a saturated world. No sampler change and no tunnel tightening
can move it -- which is why widening the sampler correctly changed nothing.
So 0 proved on this fixture is the RIGHT answer, and informative: the prize
shrinks to nothing as caves saturate. It is simply not an answer about
production.
Check 4 is now a lambda run twice -- parameterised rather than copy-pasted,
because two copies of the criterion would drift and the second would lie:
[dense fixture] as before, expected to stay ~0 and now documented as correct;
[production defaults] the same 40 tiles against RoomSpacing 80 / RoomDensity
0.35, the real UVoxelStrateDefinition defaults. Both brute-forced voxel by voxel.
Not "widen it until it passes": the dense run stays in the report, must stay ~0,
and a false verdict in either still fails. The two stacks deliberately share
FRoomGraphSource's thread_local caches, so this run and check 3 now watch each
other through the params fingerprint in the key.
Unbuilt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
f2fefade4c |
test(opstack): the tile sampler never left the (0,0) spine -- widen it to 4x RoomSpacing
The per-class breakdown refuted my own hypothesis on its first run. I predicted "tunnels >> rooms, so it is capsule bounding spheres". Tunnels ARE wildly over-counted (69.2 of 80.4 reach), but rooms hit all 40 tiles too, so fixing tunnels alone would have moved the number by exactly zero. Fourth confident chain this refactor that reversed on contact with a measurement. The real finding is that the measurement was invalid. The sampler drew tile XY from RandRange(-4,4)*8, i.e. +/-32 voxels, against RoomSpacing = 80 and a guaranteed OriginRoomRadius = 20 room at (0,0) whose cull radius is 42, with the (0,0) spine descending exactly there. All 40 tiles sat inside the origin room's cull sphere, in the most cave-riddled spot in the world. "4.9 of 7.2 rooms reach" was measuring the spine hub, not the world's cave density -- every conclusion about whether deep rock is provable was answering another question. Widened to +/-320 voxels (4x RoomSpacing). The report now prints its own sampling extent and how many tiles landed clear of the spine, because a sampler whose extent you cannot quote is one nobody is watching. This changes what the measurement LOOKS AT, never what it demands: every verdict is still brute-forced voxel by voxel, so a wider sampler that produced a false verdict still fails. Also worked out, before writing any code, why rooms cannot be tightened and tunnels can. SmoothMin's penalty is exactly zero once |A-B| >= K, so the running minimum saturates at K below the true minimum and Sdf >= min_i(SDF_i) - K for ANY number of primitives. With K=4, WormNetworkRange=24, mods gating at 3K=12, the threshold T is 24. For rooms the cull rejects at Rmax+3K=57 while an "Sdf >= T+K" test rejects only at Rmax+T+K=73 -- the cull is strictly better. For tunnels the cull is a capsule BOUNDING SPHERE, radius up to ~107 for a 200-long tube of radius 7, while the real segment distance rejects at 35. An order of magnitude, and sound because TaperedCapsule is a genuine distance function (verified, not assumed). That disjunction is NOT in this build on purpose: it changes what Identity means here, from "Sdf stays FLT_MAX" to "Sdf >= T", which is only sound if every consumer threshold is <= T. Three premises still need reading rather than assuming -- VF_NearCaveSurface's constant, the Blend passed to FSdfConvertOp, and whether any modifier re-probes the SDF outside the box before its gate. Fix the measurement first; it costs nothing and it is wrong today. Unbuilt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
8043a613c3 |
perf(opstack): drop the redundant column test, and measure WHICH primitive class blocks the box
The worm fix worked -- attribution now reads "AllSolid killed by: RoomGraphSource x40", with WormFieldSource gone from the list. The blocker moved one operator upstream. And my own warning is now the thing to distrust. It said "if it names RoomGraphSource, the tiles genuinely straddle cave", which is a hypothesis wearing the costume of a conclusion -- the same mistake as the previous warning, one level down. RoomGraphSource has four primitive classes behind it whose bounds differ enormously in quality. No third guess. PROVED, not guessed: the columns test is removed. It treated columns as infinite cylinders in Z (the cache gives them no vertical bound), so a box hundreds of voxels below the owning room answered Both over a shared XY circle. It was REDUNDANT rather than conservative: columns are read by exactly one operator, FRoomColumnMod, whose Eval opens with VF_NearCaveSurface(InOut.Sdf, ...). In a box no room/tunnel/pit/chimney reaches, Sdf stays FLT_MAX everywhere, so no column can execute wherever it sits in XY. Removing it tightens the verdict without touching correctness. THE INSTRUMENT: EffectOverBox no longer early-outs on the first hit, it counts all four classes -- stopping at the first gives the right verdict and no information, which is exactly why "RoomGraphSource x40" was unactionable. Free at the scale that matters: BuildChunkCache has just run and dwarfs a walk over ~100 structs, and the verdict is memoised so the walk happens once per box. GetLastRoomBoxDiagnostic reads back what the operator computed rather than letting the test re-derive the criterion. The test could replay it -- and that second definition would drift from the real one and lie on the day it was believed. Same reason VF_BuildOpStackForChunk exists. The hypothesis it exists to kill or confirm: a tunnel is culled per voxel by its BOUNDING SPHERE, an enormous over-estimate for a long thin capsule, while a room's cull sphere is a fair fit. Tunnels >> rooms would mean the box test is losing to capsule bounding spheres rather than to real cave. NOT done deliberately: tightening tunnels to a true capsule test is not free correctness -- the per-voxel cull IS the bounding sphere, so a capsule test would be tighter than the cull and would break the stated criterion. Making it sound needs "no primitive can bring Sdf below max(Blend, SDFBlendRadius*3, WormNetworkRange)", which needs a bound on how far SmoothMin of N primitives dips below min. Real 0.2 design work, and doing it blind before knowing whether tunnels are even the problem is the C10 mistake verbatim. Unbuilt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
f537648867 |
fix(opstack): the worm inherits the room source's box verdict -- the actual blocker
First build of the spatial EffectOverBox came back green with 0 tiles proved of 40. The warning written for exactly that case fired, and then was not good enough: it offered two candidate causes and BOTH were wrong. The real one was a third operator neither candidate mentioned. FWormFieldSource answered CarveOnly unconditionally with a provably correct amplitude bound of WormStrength. But BaseDensity = 8 and WormStrength = 10 are the DEFAULTS -- the field's own comment requires the worm to exceed BaseDensity or it could never carve air. So SolidMargin = 8 - 10 < 0 on every tile of every strate with worms on, before the fold reached anything the room source proved. A numerically correct bound that is structurally always fatal. The fix was already written three lines up in the worm's own Eval: NetworkMask is 0 when CaveSDF >= WormNetworkRange, which FLT_MAX always satisfies. The worm IS spatially bounded -- by the room source's bound, exactly like the twelve detail modifiers -- so where the source proves Identity it does not execute at all. Thirteen inheritors instead of twelve. Verified FVoxelOpSample::Sdf really does initialise to FLT_MAX rather than assuming it; the inheritance inverts into a hole otherwise. Deliberately NOT VF_NoCaveOverBox: that helper answers "identity" for a null Rooms, correct for the twelve modifiers and wrong for an op a future assembly could place behind a different SDF writer. No room source means we do not know, which must cost CPU rather than a hole. And the instrument, because the guess is the thing that cost a build: a diagnostic that lists candidate causes without measuring them is still a guess wearing rigour. FVoxelOpStack::ClassifyBoxAttributed reports the index of the first op that kills each hypothesis -- same loop, same early-out, verdict identical to ClassifyBox, because a diagnostic that takes a different path than the thing it explains sends you hunting in the wrong place. IVoxelDensityOp::DebugName gives them names and touches no cache key, so it cannot change the world. Check 4 now always prints "AllSolid killed by: <op> xN", and the zero-proved warning says to read it instead of re-deriving. Unbuilt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
03ddcde334 |
feat(opstack): FRoomGraphSource::EffectOverBox answers spatially -- and AUDIT C2 is fixed
The chain no longer dies at the room source. The criterion is the per-voxel cull
lifted from point to box, which can fail for exactly one reason: Eval starts at
MinSDF = FLT_MAX and only lowers it through a primitive that survives its own
cull, so if no cached primitive survives its cull anywhere in the box, Sdf stays
FLT_MAX across the whole box.
FSdfConvertOp already returned Identity ("la source a repondu pour la paire") and
the twelve detail modifiers already inherited through VF_NoCaveOverBox. One
function learned to answer and fourteen operators became provable -- what the C1
wiring was built for.
Three deliberate choices, all erring toward CPU rather than toward a hole:
- |Perlin3D| <= 2, derived from GradDot + the convex hull of a trilinear lerp,
instead of the header's observed "~[-1,1]". A verdict resting on an observation
is the hole this file spends its life avoiding.
- the op pool is passed to BuildChunkCache, not nullptr: the bake reads OpParams
to place pits and chimneys, so nullptr would under-bound the cache and could
return Identity over a real pit.
- the search box is wider than Eval's, giving a superset of primitives.
The verdict is memoised per box (all twelve modifiers ask the same question), and
the cache is a SECOND per-worker cache so classification cannot disturb a live
generation's hot cache.
AUDIT C2, confirmed 2026-07-28, is fixed on the switch path in the same breath:
GetDensityWithParams now takes required ParamsFingerprint + LayoutVersion. The
alternative this audit section used to recommend -- add chunk Z to the key -- is
insufficient (Interleaved makes Alpha depend on chunk XY too) and destructive
(chunk XY is deliberately absent so gradient probes don't thrash the box, ARCH
8.10). The CRC is taken once per chunk where the params memo already lives, so
the per-voxel cost is two integer compares. The three test call sites pass it
too, so the oracle stops sharing the defect it tests.
Check 4 of the tunnel test no longer asserts "0 proved" -- that assertion would
now forbid the gain. It brute-forces every proved tile voxel by voxel instead and
reports the count, because a false verdict leaves no geometry and no collision
behind it.
The second debt (per-room ops can raise a modifier's amplitude above the strate
params a box bound reads) turned out to be DORMANT, not live: where the source
proves Identity the modifiers' gate never opens, and where it answers Both it
supplies no MaxCarveOverBox so nothing is provable anyway. It goes live the day
the source gains one. Written at the site.
Unbuilt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
e55f12a9de |
docs(handoff): ce409e7 is built -- turn the Underwater section from a task into a question
Two green builds now, so the handoff's most prominent instruction (build
|
||
|
Fr0zka
|
b533294f5d |
docs(opstack): record the green build and rewrite the handoff for a fresh context
OPSTACK-PROGRESS gets the measured entry: every number the run produced, what each one settles, and the single open warning. OPSTACK-PLAN's status header goes from UNVERIFIED to BUILT AND GREEN. OPSTACK-HANDOFF is rewritten end to end. It no longer describes a transition in progress but a completed one, and it leads with the two things a cold context needs: the Underwater 0%-coverage warning (with the truncation-vs-floor finding behind it, and the reminder that a green bit-identity over solid rock is not evidence), and the one task everything else now waits on -- making FRoomGraphSource::EffectOverBox answer spatially. It also carries forward the two debts that must be paid BEFORE that lands rather than after: box bounds computed from strate params can be too optimistic once a per-room op raises them, and AUDIT C2 is confirmed but unfixed on the switch path. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
ce409e7bb1 |
test(opstack C2): floor-divide the sampled chunk range, and DIAGNOSE the Underwater 0% instead of guessing
The build is green: 14 tests, TunnelNetwork A+B bit-identical over 6000 samples, all twelve group probes non-zero, all 8 roughness variants identical, 0 gate leaks, C1 proved (10 Terrace rooms, 1119 samples inside them). One warning fired, and it is the one the test exists to fire: Underwater (stage C2): 2000 samples, 0 of them in open cave (0.0%) A GREEN BIT-IDENTITY OVER 2000 SAMPLES OF SOLID ROCK IS NOT EVIDENCE. It is exactly what two agreeing voids look like -- the 1.1% run of stage A, again, in a different slot. A REAL BUG FOUND WHILE DIAGNOSING IT The sampled chunk-Z range used Z / CHUNK_SIZE, and C++ integer division TRUNCATES TOWARD ZERO. TunnelNetwork sits at the top of the layout in positive Z, where truncation and floor agree, so it could not show there. Underwater sits at the BOTTOM, in NEGATIVE Z: -1 / 32 is 0 by truncation and -1 by floor, so the upper chunk bound starts one notch too high and the Clamp that follows piles the excess onto the strate's very last voxel -- inside the top seal band, i.e. solid rock. Fixed in both point builders via FloorDivChunk. Same family as the DivideAndRoundDown lesson already in the project notes: truncation costs a build cycle every time it is assumed to be a floor. That is a CANDIDATE cause, not a conclusion, so the commit does not stop there. NEW CHECK 5b -- ASK, DO NOT INFER Three causes produce "no sample in open cave" and they are fixed differently, so each now has its own number: rooms baked for the Underwater strate index (cause: the bake), samples landing inside the seal-free interior (cause: the sampled Z range), and the two together (cause: the XY spread). The info line says explicitly how to read them. Sampling also widens from 8 clusters to 24, matching the main scan. Fourth application of the rule this archetype keeps teaching: the check that explains a zero must be able to fail for exactly one reason. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
46b507a261 |
docs(opstack): close the unattended run -- the post-8/8 batch and the reviewer pass
Four commits after 8 of 8, logged in OPSTACK-PROGRESS with the same shape as the first entry: what each touches, what breaks first, and the numbers to read before the colours. Records three things that only became visible while doing the work: 1. DECOMPOSITION 0.2 frames the worm as THE blocker for tile skipping. It is one of three. The subtraction also had no first term (nothing declared how solid the rock was), and the twelve detail modifiers were the bigger drag -- not through their amplitudes but because they declared a direction where they are provably Identity, being gated on the SDF the room source writes. 2. A safety property that was checked rather than assumed: no box query anywhere in the operator library touches per-worker memo state. That is what makes it safe for ClassifyTile to build and fold its own stack without clobbering the caches the density path depends on. 3. The reviewer pass over every ported operator found no transcription error. It did confirm the four things a future reader would otherwise have to re-derive: the operator order matches the original line for line, EffectiveZ is recomputed per op but bit-identically, the terrace's SDFBlendRadius is equal on both paths because no ApplyTo writes it, and LocalParams() is lazy so it reproduces the original's cost profile rather than merely its value. Next action is now one thing rather than a queue: make FRoomGraphSource::EffectOverBox answer spatially. Both of this batch's mechanism commits were built to receive it. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
6a8390f11f |
feat(opstack): ClassifyTile consumes ClassifyBox for cave archetypes -- the T1.d prize, behind the same opt-in
⚠️ THIS IS THE ONE COMMIT OF THIS RUN WHOSE FAILURE MODE IS A HOLE, NOT A REGRESSION. A non-Mixed verdict makes the world skip GenerateMesh entirely: no triangles, no collision, invisible until a player falls through. Read VoxelForge.OpStack.ClassifyTileSoundness before trusting it. WHAT CHANGED ClassifyTile used to `return Mixed` without a call for every cave archetype ("archétype cave [...] pas prouvable en v1"). It now builds that strate's stack and folds ClassifyBox. SurfaceWorld and bedrock gaps keep their hand-written proofs untouched -- the exact-lattice column test is strictly better than any box bound, so the stack has nothing to add there. ONE DEFINITION OF THE STACK MAPPING, and that is the load-bearing part GetDensityAt's ~90-line build switch is extracted into VF_BuildOpStackForChunk and both callers now use it. A second copy would be the worst bug available here: a tile skipped on the verdict of a stack that is not the one producing its density is precisely a hole. A "keep these in sync" comment would not have been enough; there had to be only one. Params are passed in by pointer, never fetched inside, because both callers already have them. SIX GUARDS, ALL FAILING TO MIXED, none giving the benefit of the doubt 1. The strate must actually opt in -- on EVERY chunk coord the box touches, not just the one that triggered the attempt. Otherwise the classifier judges a field the mesher will not produce. 2. One cave slot per tile. Two slots means two param sets, and a stack answers only for its strate. 3. No mixed cave/surface/gap tile: the cave stack's box would cover Z belonging to another strate. 4. The params must be BIT-IDENTICAL across every chunk coord the box touches. This is the guard that matters, and it exists because of the finding committed earlier today: GetGenerationParams blends params inside a strate (Alpha depends on chunk Z for Gradient, and on chunk XY as well for Interleaved), so one stack genuinely cannot represent a tile that straddles a transition band. Memcmp on POD: differing padding can only produce a false MISMATCH, i.e. one Mixed too many. 5. A 27-chunk-coord cap, so a very wide tile does not pay for the check. We give up the gain, never the safety. 6. The disturbances are folded by hand (chasm ⇒ CarveOnly, bridge/ridge ⇒ FillOnly), because DECOMPOSITION 10.2 leaves them OUTSIDE the stack -- GetDensityAt applies them after the negate. A verdict that ignored them would be wrong exactly where they act. Same inequalities the SurfaceWorld branch already uses. The diff layer needs no new guard: ClassifyTile already returns Mixed for any tile with player mods in range, before any of this. TEST: VoxelForge.OpStack.ClassifyTileSoundness -- the same brute-force oracle as the existing ClassifyTileSoundness, on a world where every strate opted in. It does not check the fold (that is BoxVerdictFold) or the operators (those are the eight equivalence tests); it checks the WIRING. The number to read first is the count of tiles actually brute-forced: zero non-Mixed verdicts would mean the test proved nothing, so that case is an ERROR rather than a quiet pass. Its failure message lists the four suspects in the order worth checking. FIXTURE: FTestWorld::Build gains a bUseOperatorStack parameter (default false, so the thirteen existing tests still exercise the switch), and every test world now gets a PROCESS-UNIQUE LayoutVersion. That second change fixes a real cross-test hazard that was only ever hidden by an accident: PassagesVersion is per-instance and starts at 0, so two FTestWorlds both reported 1, and GetDensityAt's per-chunk caches are keyed on (ChunkCoord, LayoutVersion) -- one world could be served the previous world's params AND its CP_UseOpStack flag. Invisible while every world agreed the flag was false. The first world that ticks it removes that coincidence, in both directions. WHAT THIS BUYS TODAY: Maze, FlatPlain/CrystalChamber, VerticalShafts and FloatingIslands can now prove tiles in production, which is where the measured skipping (Maze 23/60, slabs 36-40/60) turns into frames. TunnelNetwork and Underwater still prove nothing: their chain dies at FRoomGraphSource, which answers Both with unknown amplitude. Making it answer spatially means building the SDF cache for the queried box -- now worth doing, since a skipped tile saves 30k+ density evaluations, and the amplitude fold plus the modifiers' Identity inheritance are already in place to receive it. That is the next piece. And nothing here changes Jahni's current world: no strate asset has bUseOperatorStack ticked, so every guard above is unreachable in his project until he ticks one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
239c037f35 |
feat(opstack): the twelve detail modifiers inherit the room source's box verdict
Follow-on to the numeric fold, and the reason that commit does not yet pay off on TunnelNetwork. Separate commit because it is a separate mechanism with a separate revert story: the fold change was about AMPLITUDES, this one is about IDENTITY. THE OBSERVATION Every one of the twelve detail modifiers is gated on bNearCaveSurface, i.e. on Sdf < BlendRadius*3, and Sdf only becomes finite if the room graph wrote something. So wherever the source proves that no room and no tunnel reaches the box, Sdf stays FLT_MAX across the whole box and all twelve are IDENTITY -- not merely bounded, not merely CarveOnly-with-a-small-number. Identity. Each of them already knew this per voxel (it is their first `if`) and still declared Both / FillOnly / CarveOnly per box, which killed deep bedrock's AllSolid hypothesis exactly as hard as an operator that genuinely acts there. Twelve over-cautious declarations, one cause: they were not asking the source they depend on, although since C1 they already hold a pointer to it. VF_NoCaveOverBox(Rooms, Box, Ctx) short-circuits each EffectOverBox to Identity when the source itself answers Identity. Strictly conservative: it never returns Identity on its own authority, only where the source already did. A null pointer also means Identity, and that is correct rather than convenient -- with no room source in the stack, Sdf is FLT_MAX everywhere and the gate never opens. FCaveRoughnessMod gains the pointer purely for this. It is named RoomsForBox and documented as NOT for Eval, because that op deliberately reads STRATE params rather than LocalParams() and mixing the two up is the exact mistake C1's note exists to prevent. ⚠️ WHAT THIS BUYS TODAY: almost nothing, and that is worth stating rather than implying. FRoomGraphSource::EffectOverBox still answers Identity only when RoomDensity <= 0. The short-circuit becomes the deep-bedrock switch on the day the source answers SPATIALLY -- its room and tunnel bounds are already in the SDF cache; what it costs is building that cache for the queried box, which only pays once ClassifyTile actually consumes ClassifyBox. The wiring is put in now so that day touches ONE place instead of thirteen. No test change: this can only turn Both/FillOnly/CarveOnly into Identity where the source already returned Identity, so no existing verdict can move. The TunnelNetwork test still asserts 0 proved verdicts over 40 tiles, and it should still hold. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
353d504169 |
feat(opstack): the box fold carries NUMBERS -- amplitude bounds alongside EVoxelOpEffect (DECOMPOSITION 0.2)
Its own commit, nothing else in it, because it changes the contract all thirteen tests rest on. VoxelForge.OpStack.BoxVerdictFold is extended in the same commit, as required. THE PROBLEM, restated because the fix only makes sense against it Direction alone can never recover a FIELDED carve. A noise-threshold carve (TunnelNetwork's worms, wall roughness) has no spatial bound: it answers CarveOnly on every box of every strate that enables it, and that answer is TRUE. So it kills AllSolid everywhere and the archetype skips zero tiles. No refinement of EffectOverBox can fix that. But the AMPLITUDE is bounded, and for the worm it is trivial: the block only runs below the threshold, so t = 1 - WormValue/WormThreshold is in [0,1] and NetworkMask is in [0,1], hence the carve is at most WormStrength. "The rock is solid by more than the sum of every remaining carve" is therefore provable. THE CONTRACT - IVoxelDensityOp gains MaxCarveOverBox / MaxFillOverBox (density units, FLT_MAX = unknown) and ForcedMarginOverBox (how far the density is guaranteed from zero, 0 = unknown). - FVoxelBoxHypotheses gains SolidMargin / AirMargin. A forcing op sets one; each carve subtracts its amplitude; the hypothesis dies when the margin is no longer strictly positive. - VF_ForceHypotheses and VF_FoldEffect take the new values as DEFAULTED parameters. BACKWARDS COMPATIBILITY IS THE POINT, and it is structural rather than promised: the defaults are FLT_MAX and 0, so an op that overrides nothing subtracts FLT_MAX from a margin of 0 and kills the hypothesis exactly as the purely directional fold did. Not one existing verdict moves. The float arithmetic is deliberately unguarded: 0 - FLT_MAX is -FLT_MAX, -FLT_MAX - FLT_MAX saturates to -inf, -inf > 0 is false, and no NaN is reachable because both terms share a sign. BOUNDS DECLARED (each proved from the code, not estimated -- over-estimating costs CPU, under-estimating is a hole) - FConstantFieldSource::ForcedMarginOverBox = |Value|. This is the missing FIRST TERM: without a source that states how solid the rock is, there is nothing for a bounded carve to be subtracted from, and every bound would still kill the hypothesis. - FWormFieldSource: MaxCarve = WormStrength (the bound that had been written and unused since stage A), MaxFill = 0. - FCaveRoughnessMod: 1.4 * SurfaceRoughness * VOXEL_NOISE_SCALE both ways. - FLayerLineMod (LayerLineDepth), FRibbingMod (RibbingDepth), FScallopMod (ScallopStrength), FCaveOverhangMod (SCALE * Depth * Strength). WHAT THIS DOES *NOT* DO YET, said plainly rather than implied TunnelNetwork still proves ZERO tiles. The chain dies at FRoomGraphSource, which answers Both with unknown amplitude, before any of the bounded ops are reached. Making it answer spatially means building the SDF cache for the queried box, which only pays once ClassifyTile actually consumes ClassifyBox -- so it belongs with that work, not here. The one case that changes today is a tunnel strate with RoomDensity <= 0: the room source returns Identity and the bounded worm + roughness can now leave AllSolid standing. Seven ops keep the FLT_MAX default (terrace, cliff, arch, column, dome, pinch, floor bias). Their amplitudes depend on room-relative data, and bounding them would change no verdict while the room source is unbounded. Writing bounds nobody can consume is how a bound goes stale unnoticed. ONE PRE-EXISTING DEBT MADE SHARPER, noted at every site: these bounds are computed from STRATE params, and a per-room terrain op can write a LARGER amplitude (ApplyTo overwrites even where the strate had 0). So a bound can be too small -- the dangerous direction. Same root as the too-optimistic EffectOverBox flagged in C1, same fix, and it MUST land before ClassifyTile consumes ClassifyBox. TEST: eight new blocks in BoxVerdictFold. The first two are the ones to read -- they assert that the defaults reproduce the old fold exactly, and that "unknown" is not "zero". Also asserted: carve amplitudes accumulate; equality loses the tile (the > is strict on purpose, since zero counts as air at the mesher); a bounded Both no longer kills a margin it cannot cross; and nothing bounded can resurrect an unprovable box. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
64d0e11821 |
docs(audit C2): the within-strate stale-room suspicion is CONFIRMED by reading -- and it is the default config
No code changed. AUDIT-2026-07.md only: §C2's "SUSPECTED, NOT PROVEN" sub-item becomes "CONFIRMED BY READING", with the four links of the chain and where each one is in the source. THE CHAIN, checked instead of believed 1. GetGenerationParams' Gradient arms compute Alpha = 1 - DistFromBottom / EffectiveBlend, where DistFromBottom = ChunkCoord.Z - Slot.BottomChunkZ. Alpha is therefore a function of chunk Z WITHIN the slot -- so two chunk Zs in the same strate really do get different params. The top boundary mirrors it. 2. They differ in exactly the fields that place rooms: Lerp expands VF_STRATE_PARAM_FIELDS, which lists RoomSpacing, RoomDensity, MinRoomRadius, MaxRoomRadius, RoomHeightRatio, RoomShapeVariety, SDFBlendRadius, CaveWarpStrength and the tunnel fields -- every input BuildChunkCache reads. 3. It is the DEFAULT: TransitionType = Gradient, TransitionBlendChunks = 2. Two chunk-Z layers with distinct params at each end of every strate, out of the box. 4. StrateIndex cannot save it: the memo resolves the SLOT index from the band centre, identical for every chunk Z in the slot, and the cache key's XY box does not change as a worker walks down a column. No rebuild happens. So a worker that builds (X,Y,Z1) then (X,Y,Z2) in one strate evaluates the second chunk against the room list baked from the first chunk's params. WHY IT MATTERS MORE THAN A SEAM The result depends on which chunk that worker happened to build first. That is a window-invariance break (ARCHITECTURE 8.4), not a cosmetic one, and in multiplayer two peers can generate different geometry for the same chunk from the same seed -- a direct 2.6.1 violation on the ORIGINAL path. WHY NOTHING CAUGHT IT The test fixture sets TransitionType = Hard on every strate deliberately, so that "which archetype owns this chunk" stays unambiguous. That switches the blend off entirely. The one configuration the tests never build is the default one. NOT FIXED HERE, deliberately: this is the switch path, and the fix (fold a params CRC + LayoutVersion into the SDF cache key, exactly as FRoomGraphSource already does) is a behaviour change to live generation that Jahni should land with a build in front of him. The operator stack does not inherit the bug. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
10dbe64b06 |
feat(opstack C3): TunnelNetwork + Underwater in the ported list -- 8 of 8
UsesOperatorStackForChunk now returns true for both, so the archetype switch has a complete operator-stack twin: per-strate opt-in, every archetype equivalence-tested bit for bit against its original function. This changes nothing by itself. The flag still requires bUseOperatorStack ticked on a strate asset, which is Jahni's call and was deliberately NOT done. What HAS changed is that the flag is no longer a no-op anywhere: ticking it on any strate now really switches that strate onto the stack. Not done, and it is the next real prize: ClassifyTile still uses hand-written guards and does not consume ClassifyBox. That is where measured tile-skipping becomes frames. DOCS - CODEMAP 3.2d: ported list 6 of 8 -> 8 of 8; the BuildTunnelNetworkStack row rewritten (19 ops, one builder for two archetypes); six new rows for the detail modifiers, each carrying the thing a reader would otherwise have to rediscover -- roughness reads STRATE params, terrace re-queries the SDF, the cliff's comment disagrees with its code, columns have no strate parameter at all, and LocalParams() is the override whose EffectOverBox is too optimistic on a strate with an op pool. Also corrected the stale "never compare the two paths" line: C10 is closed and all eight equivalence tests compare bit for bit. - CODEMAP 3.3 UsesOperatorStackForChunk row: same list, plus the warning that the flag is now a real switch rather than a harmless tick. - OPSTACK-PLAN: status header and the Phase 2 order both updated; the three-stage TunnelNetwork breakdown and the calls-not-transcribes rule recorded there rather than only in the code. - OPSTACK-PROGRESS: the closing entry for this unattended run -- every commit in order, the five original-code findings ported as-is, the two decisions that are not reversible by taste, the ClassifyBox optimism C1 introduced and that must be fixed before ClassifyTile consumes it, what breaks first per group, and the likely compile-error spots. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
e479fcdf7d |
feat(opstack C2): Underwater reaches the tunnel stack from a second case + its own equivalence check
STAGE C group 2. No operator, no parameter, no new stack: Underwater IS TunnelNetwork.
PREMISE VERIFIED BEFORE BUILDING ON IT (the lesson this refactor has paid for four times)
OPSTACK-DECOMPOSITION §8 claims there is no density difference at all. Both halves were re-read
rather than assumed:
- GetDensityAt already puts `case Underwater:` and `case TunnelNetwork:` in the SAME arm, both
calling GetDensityWithParams (VoxelGenerator.cpp, the production switch);
- a repo-wide search for WaterLevelRelative shows FStrateGenerationParams' copy is read only by
UVoxelStrateManager's water-level query (render side) and by the SurfaceWorld beach op through
a DIFFERENT struct. GetDensityWithParams never reads it.
So the wiring is one more `case` above the existing one, sharing CP_Tunnel.
ONE REAL DIFFERENCE FROM THE FIVE CASES ABOVE IT, stated in the code
No degenerate-strate guard. The other five archetypes have one because their density functions
early-out to `return 1.0f` on zero height and the stack has no such early-out by design.
GetDensityWithParams has no early-out at all -- read line by line, not assumed. Adding a guard here
would make the stack diverge from the switch on degenerate strates, in exactly the direction the
guard exists elsewhere to prevent.
TEST (same commit): new check 5 samples 2000 points in the Underwater SLOT, with the same room-op
pool attached to that definition before anything is evaluated. This is not tautological even
though both paths call the same function: the Underwater slot is a different strate, hence a
different StrateIndex, hence a different bake seed and a different entry in the strate-index memo.
It exercises what six chunks of slot 0 cannot -- that the stack follows the right room set when
two strates of the same archetype coexist in one world.
The failure message says explicitly that if the TunnelNetwork equivalence is green and only this
one fails, the finding is a real density difference between the two archetypes, which contradicts
§8 and is worth more written down than patched.
UsesOperatorStackForChunk still returns false for both. That is C3.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
9591088d34 |
feat(opstack C1): per-room op override -- eleven detail ops read LocalParams() from the room source
STAGE C group 1. No operator added: nineteen ops before, nineteen after. What changed is what ELEVEN of them READ. THE MECHANISM, AND WHY §2's "NO CLEAN HOME" PROBLEM DISSOLVED FRoomGraphSource gains LocalParams(): the strate params with the nearest room's hash-rolled UVoxelTerrainOpDefinition applied on top, exactly as the original's `FStrateGenerationParams LocalTerrainParams = Params; ... NR.RoomOp->ApplyTo(...)` shadow does. Every detail op that read the shadowed copy now reads that. OPSTACK-DECOMPOSITION §2 called this the piece with no clean home and proposed giving each modifier an "only inside room N" predicate. The difficulty came entirely from assuming each modifier must OWN its params. One op owns the shared state, the rest read it -- and that pattern was already established here twice (FOverhangShelfMod <- FSurfaceColumnSource, FShaftLedgeMod <- FShaftFieldSource). No scoping predicate was invented. Same shape as the pit/chimney resolution. ELEVEN, NOT TWELVE, AND THAT IS READ FROM THE CODE Surface roughness (4b) does NOT read the per-room copy: the original's `const FStrateGenerationParams& Params = LocalTerrainParams;` is declared INSIDE the `if (bNearCaveSurface)` block, which begins after step 4b. Ported that way and flagged in the op so it does not get "uniformised" later. MEMOISED PER VOXEL, AND WHY THAT IS FIDELITY RATHER THAN OPTIMISATION The original builds the copy ONCE per voxel inside the gate. Eleven ops calling LocalParams() would build it eleven times. So FState carries a valid-flag that FRoomGraphSource::Eval clears at the top of every voxel (before any early-out, so nothing can read the previous voxel's room), and the first modifier that asks pays for it. Deep rock pays nothing, exactly as before. The ~74-field copy itself is TRANSCRIBED AS-IS. It is a real per-voxel cost; recorded in OPSTACK-PROGRESS as a perf item, not "improved" here. ONE THING THIS EXPOSES, WRITTEN DOWN BEFORE IT BITES EffectOverBox still answers from the STRATE params, because a box spans many rooms and a per-voxel copy has no meaning there. Since ApplyTo writes the op's value even where the strate's was 0, a room op can ENABLE a modifier the strate had off -- so a box verdict can now be too optimistic on a strate that has a terrain-op pool. Harmless today (nothing consumes ClassifyBox in production) and it MUST be fixed before ClassifyTile does. Noted at FLayerLineMod::EffectOverBox and in OPSTACK-PROGRESS. TEST (same commit) -- this is the acceptance stage B could not make - The pool gains a Terrace op with values (3.0 / 0.95 / 1.4) deliberately far from the strate's (6.0 / 0.6 / 0.5). A stack that ignored the override now CANNOT be bit-identical. - New check 3c asks the structure, not the density, because there is still no params probe for a pool (the pool is not in the SDF cache key): how many baked rooms carry a Terrace op, and how many samples fall inside one of those rooms' influence radius. Both must be non-zero, or check 1's green means only that two paths agree where the override never applies -- which is what stage B already proved. Fourth application of the pit lesson. IF THIS GROUP IS WRONG: check 1 fails with diffs clustered inside a subset of rooms (those that drew Terrace) and terrace-shaped Z banding, while check 3c still reports non-zero coverage. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
8a303cc085 |
test(opstack B5): prove the bNearCaveSurface gate -- a voxel outside it is bit-identically untouched
STAGE B group 5 of 5, and the only one that adds no operator. Stage B is complete: 19 ops, all
twelve detail modifiers ported.
THE DECISION, restated where it is paid for
The gate is a repeated early-out inside each operator (VF_NearCaveSurface), not a scoping
container. Reasons live in the code at that function; the short form is that the stack is a flat
list ClassifyBox folds op by op, a container would have to re-implement VF_FoldOp and would hide
its children from the fold, and an op that only exists inside a container cannot become a Phase-3
asset. What that choice buys in composability it pays for in risk: TWELVE places to forget the
gate instead of one. Hence a check aimed at exactly that.
NEW CHECK 1d
Classify each sample by its final SDF (nothing downstream of the room source writes that channel),
then compare the full stack against one with the eleven controllable amplitudes zeroed:
- outside the gate the two must be BIT-IDENTICAL -- asserted, and the leak count is printed;
- inside the gate they must differ often -- printed, and ZERO is an error, because "nothing
leaked" is worthless if the answer is "nothing happened anywhere". Same trap as a coverage
guard that only fires at zero, one level up: a check can be vacuous as well as a counter.
- the outside-gate sample count is printed and warns below 10%, since deep rock is the common
case in production and a sample set that never leaves the cave does not exercise the gate.
WHAT THIS CHECK CANNOT COVER, stated in the output rather than left implicit: the column operator
(STEP 4d) has no amplitude to zero, so it cannot appear in the zeroed stack. Its gate rides on
check 1's bit-identity against the original instead. That is sound but invisible, which is why the
info line says so.
Also corrected in the test header: the modifier count is TWELVE, not the thirteen that had been
carried in the notes, and only ELEVEN of them read the per-room param copy -- surface roughness
(4b) sits before the shadow declaration and reads strate params. Both numbers matter for C1.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
b063d437c1 |
feat(opstack B4): port Columns (4d), Domes (4g), Pinch (4h), FloorBias + Column op in the test pool
STAGE B group 4 of 5 -- and with it, ALL TWELVE detail modifiers are ported. 19 ops:
ConstantRock -> RoomGraph -> SdfCarve -> Roughness -> Terrace -> LayerLines -> Ribbing
-> Overhang -> Cliff -> Scallop -> Arch -> RoomColumn -> Dome -> Pinch -> FloorBias
-> Worms -> [structural x3]
Still NOT wired: UsesOperatorStackForChunk returns false for TunnelNetwork. What is missing is C1,
the per-room op override -- which adds NO operator, it changes what eleven of them READ.
TRANSCRIBED
- FRoomColumnMod (4d): walks SDFCache.Columns. Not FGridColumnMod -- that one rolls cylinders on a
world grid for FlatPlain/CrystalChamber; this one iterates a per-room bake.
- FDomeMod (4g): upward half-ellipsoid, up to 2 per room, capped at 0.85 * room radius.
- FPinchMod (4h): perimeter-anchored ellipsoid with the SideFactor term that leaves the passage
axis clear.
- FFloorBiasMod: quadratic fill below room centre, only in definite air. LAST in the chain and not
interchangeable -- it exists to undo what roughness (4b) did to floors. That is why the operator
order in BuildTunnelNetworkStack is the original's order line for line.
THE TRAP IN THIS GROUP, WHICH IS THE PIT LESSON A THIRD TIME
Columns have NO strate parameter. The per-voxel loop has no `if (ColumnDensity > 0)`, and the bake
reads OpParams (a FRESH struct with only the room's op applied), so FStrateGenerationParams::
ColumnDensity is read by nothing. Consequences, all three of which shaped this commit:
1. The `ColumnDensity = 0` line in the old DisableStageBModifiers was inert. It was never what
kept columns off; the absence of a Column op in the pool was.
2. No FeatureProbes entry can cover columns -- there is no param to switch off. And a second
stack built on a pool without the Column op would SHARE the thread_local SDF cache (the pool
is not in its key) and return identical densities, i.e. it would lie. Exactly the trap that
was documented for pits.
3. So the stage-A guard that ERRORED on TotalColumns > 0 is inverted in this same commit: it now
REQUIRES TotalColumns > 0. Asking the bake what it baked is the only sound check here.
DisableStageBModifiers is deleted rather than left empty: its emptiness is the measure of stage B
being complete, and an empty function still being called is how a step gets forgotten.
TEST (same commit): op count 15 -> 19; MakeShaftOpPool renamed MakeRoomOpPool and given a third
entry (Column, Probability 1.0 on all three so every room draws one of the three evenly); three
more param probes (dome/pinch/floor bias); the column guard inverted.
⚠️ THE POOL MUST STAY Pit/Chimney/Column UNTIL C1. Eleven of the twelve modifiers read the per-room
param copy in the original and the strate params here; those agree only while no room carries a
DETAIL-type op, and ApplyTo(Pit/Chimney/Column) writes only pit/chimney/column fields. A Terrace
entry would break the equivalence -- which is precisely the test C1 adds, and the only possible
proof that the override works.
IF THIS GROUP IS WRONG: dome/pinch/arch diffs land inside open cave near room centres and
perimeters; a column error shows up as a ring of diffs at fixed XY through the whole room height.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
6ec60099d6 |
feat(opstack B3): port cave Overhang, Cliff, Scallop, Arch (STEP 4c)
STAGE B group 3 of 5. The stack is now 15 ops: ConstantRock -> RoomGraph -> SdfCarve -> Roughness -> Terrace -> LayerLines -> Ribbing -> Overhang -> Cliff -> Scallop -> Arch -> Worms -> [structural x3] Still NOT wired: UsesOperatorStackForChunk returns false for TunnelNetwork. TRANSCRIBED - FCaveOverhangMod: fBM with Z frequency at 0.15x of XY, positive lobe only (rock extends INTO the cave, never away), quadratic fade. Note this is the THIRD unrelated thing called "overhang" in the plugin -- FOverhangShelfMod (SurfaceWorld) borrows the uphill terrain height and shares nothing with it but the name. - FScallopMod: cellular noise, positive lobe carved out. Second consumer of VoxelNoise::Cellular3D, which is the second reason B1 shared that body instead of copying it. - FCaveArchMod: the first ROOM-RELATIVE modifier -- it needs the room's hash, centre and radii, so it is what makes FRoomGraphSource::GetNearestRoomIdx() necessary. Its gate is NOT the shared one: CaveSDF < SDFBlendRadius (inside the cave), not < SDFBlendRadius*3. PORTED AS-IS THOUGH THE ORIGINAL'S OWN COMMENT DISAGREES WITH ITS CODE FCaveCliffMod's comment promises "sample density at Z+1 and Z-1, compute vertical gradient". The code samples nothing: it draws a Perlin whose Z frequency is 3x its XY frequency and names the result VertGrad. It is a gradient-shaped PROXY, decorrelated from the wall's actual slope; the multiply by CaveSDF still gives it the right SIGN either side of the surface, which is why it produces steeper faces at all. Fixing it would change the world, and saying nothing would leave it to be "fixed" later by someone reading the comment instead of the code. Ported, documented in the op, recorded in OPSTACK-PROGRESS. ONE DELIBERATE ADDITION FCaveArchMod bounds-checks NearestRoomIdx with IsValidIndex before indexing; the original tests only >= 0. The index comes from EvaluateSDFCached so it is valid by construction, which is exactly why this can never change output -- only prevent a crash if that invariant ever breaks. Same class of decision as the params fingerprint in the cache key: err on cost, never on result. Overhang is FillOnly, Scallop is CarveOnly, Arch is FillOnly; only Cliff needs Both. Four of the eight modifiers ported so far keep a usable direction for the fold, which matters for the DECOMPOSITION 0.2 work later. TEST (same commit): op count 11 -> 15, four params groups move into EnableTunnelFeatures, four more per-operator coverage probes. ArchDensity is set to 0.9 rather than its 0.1 default and the reason is written down: at 0.1 a room draws ~0.3 arches and the probe would report zero with nothing wrong. Test coverage settings are not production values. IF THIS GROUP IS WRONG: diffs concentrate inside open cave (arch) or in a band |SDF| < range (the other three), and the roughness/terrace probes stay green. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
ab1a996cc5 |
feat(opstack B2): port Terrace, LayerLines, Ribbing (STEP 4c) + hoist the room source's per-worker state
STAGE B group 2 of 5. The stack is now 11 ops: ConstantRock -> RoomGraph -> SdfCarve -> CaveRoughness -> Terrace -> LayerLines -> Ribbing -> Worms -> [structural x3] Still NOT wired: UsesOperatorStackForChunk returns false for TunnelNetwork. STRUCTURAL CHANGE THIS GROUP FORCED FRoomGraphSource's thread_local SDF cache moved out of Eval into a `static FState& State()` accessor, because terracing re-queries the cache at Z+-1 and (from B4 on) columns walk it and the room-relative ops need NearestRoomIdx. Kept `static`, i.e. SHARED BETWEEN INSTANCES, on purpose: that is what the original does, and the test's stale-cache check (check 3) rests on two stacks sharing this cache while the params CRC in the key keeps them from serving each other's rooms. Making it a member would have turned that check green for the wrong reason. This is the established pattern in this file, not a new one: FOverhangShelfMod reads FSurfaceColumnSource, FShaftLedgeMod reads FShaftFieldSource, both via a non-owning pointer handed over at build time. Terrace now reads FRoomGraphSource the same way. TRANSCRIBED - FCaveTerraceMod: the Z-only SDF gradient orientation gate, the optional noise displacement of Z before the staircase, the Edge = lerp(0.45, 0.02, Hardness) stair profile, the quadratic fade. - FLayerLineMod: sine along Z, half-wave rectified, CUBED, subtracted. - FRibbingMod: same sine shifted by PI/2, rectified, SQUARED, added. THINGS THAT LOOK WRONG AND WERE PORTED AS-IS - Terrace's two gradient probes use UNWARPED X/Y and RAW Z, while the field they probe was evaluated at WARPED coords and effective Z, and they exclude pits/chimneys. So the probe does not sample exactly the field whose slope it measures. Real, in the original, load-bearing for the look; noted in OPSTACK-PROGRESS rather than fixed. - Terrace/LayerLines/Ribbing use raw WorldZ while roughness uses EffectiveZ. Deliberate in the original (geology stays horizontal whatever the strate's vertical scale). - `&& CaveSDF < FLT_MAX` is redundant under the bNearCaveSurface gate; kept. - NearestRoom is now reset to -1 unconditionally, which the original does not do (its thread_local keeps the previous voxel's value when RoomDensity <= 0). Unobservable there because no consumer runs; here the consumers are separate objects, and a stale value crossing an operator boundary is not something you find later. Ribbing and LayerLines are FillOnly / CarveOnly rather than Both -- two detail modifiers that keep a usable direction for the fold, which is more than the roughness or the terrace can say. TEST (same commit): op count 8 -> 11; the three params move from DisableStageBModifiers into EnableTunnelFeatures with spacings deliberately small against the sample window; three MORE coverage probes, one per operator rather than one per group -- a single "B2" probe would stay green while two of the three were wrong. IF THIS GROUP IS WRONG: diffs cluster where |SDF| < spacing*1.5 near horizontal surfaces (terrace) or in thin Z bands (lines/ribs). If instead the whole equivalence collapses everywhere, suspect the FState hoist, not the three new ops. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
6e29cbfe4c |
feat(opstack B1): port TunnelNetwork surface roughness (STEP 4b) + share the cellular noise
STAGE B of TunnelNetwork, group 1 of 5. The stack is now
ConstantRock -> RoomGraph -> SdfCarve -> CaveRoughness(4b) -> Worms -> [structural x3]
8 ops (was 7). Still NOT wired: UsesOperatorStackForChunk returns false for TunnelNetwork.
TRANSCRIBED
- FCaveRoughnessMod (VoxelDensityOpStack.cpp): STEP 4b literally -- two octave sets
(main + fine x3 with the +2000/+2500/+3000 offsets), the optional domain warp, the four-way
noise switch, the min(TotalRough, 0) anti-fill clamp inside definite air, and the quadratic
fade by distance from surface. Reads EffectiveZ, not WorldZ.
- VoxelNoise::Cellular3D moved verbatim from VoxelGenerator.cpp's `static CellularNoise3D` into
VoxelCaveMorphology.h; the generator keeps a one-line forwarder, exactly as FractalNoise3D and
RidgedNoise3D already do since T2.a. It lands in the cave header rather than VoxelNoise.h
because it needs VoxelHash, and VoxelNoise.h must not depend on the cave header. Forking a pure
function is how AUDIT C1 happened.
- HRidged3D added next to HFractal3D (same FVector round-trip, deliberately).
TWO THINGS THAT LOOKED WRONG AND WERE PORTED AS-IS
- The domain warp computes ONE offset and adds it to BOTH noise positions, so the main and fine
octave sets are warped identically. Two independent warps would be tidier and a different world.
- Roughness reads the STRATE params, NOT the per-room override. The original's
`const FStrateGenerationParams& Params = LocalTerrainParams;` shadow is declared INSIDE the
`if (bNearCaveSurface)` block that begins after step 4b. So eleven of the twelve detail
modifiers read the room copy and this one does not -- flagged in the op so C1 does not
"uniformise" it. (The handoff's "all 13 modifiers read the shadowed copy" is off on both counts:
it is twelve modifiers, and one of them is outside the shadow.)
STAGE B5 DECIDED HERE, WITH REASONS (VF_NearCaveSurface)
The gate is a repeated early-out per op, NOT a scoping container: the stack is a flat list that
ClassifyBox folds op by op, a container would have to re-implement VF_FoldOp and would hide its
children from the fold, and an op that only exists inside a container is not a Phase-3 asset.
Cost stated rather than hidden: the original tests once and skips twelve, the stack tests twelve
times. Measured before optimised -- that is the C10 lesson.
TEST (same commit)
- Op count 7 -> 8.
- SurfaceRoughness/DomainWarp moved from DisableStageBModifiers into EnableTunnelFeatures.
- NEW check 1b, group coverage: rebuild the stack with the group OFF and count moved samples.
Zero is an ERROR, not a warning -- a ported group that never executes is exactly how a bad
transcription survives a whole green run (the PitDensity lesson). This diff-of-stacks is sound
here although it lied for the op pool, because these are params and the params CRC IS in the
SDF cache key.
- NEW check 1c: all 4 noise types x {warp off, warp on} compared to the original over 1500 points.
The main equivalence only ever takes the FBM branch; three of four cases were untested.
IF THIS GROUP IS WRONG, what breaks first: the main equivalence reports diffs concentrated in
open cave and within |SDF| < SurfaceRoughness*2; if instead only check 1c fails, the fault is
inside one branch of the noise switch and nothing else is implicated.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
Fr0zka
|
7a87cdda14 |
docs: handoff — take the unattended queue all the way to 8 of 8
Jahni, twice and explicitly: he is fine with unverified work as long as it is committed per group, and he wants the successor working toward full op stack completeness. So the queue no longer stops at stage B. Removed the hard stops on stage C and on flipping the ported list. Two facts make that reasonable rather than reckless, and both are now written down: committing per group IS the safety net (he reverts by sha), and reaching 8 of 8 does not change his world by itself — UsesOperatorStackForChunk still returns false unless a strate has bUseOperatorStack ticked, so the flag flip is inert until he ticks a box. Queue is now B1-B5 (13 detail modifiers), C1 (per-room op override), C2 (Underwater, which §8 establishes has no density difference at all), C3 (both into the ported list = 8 of 8), then the §C2 audit question, the worm amplitude cap, and making ClassifyTile consume ClassifyBox. C1's design is settled here rather than left open, because an unattended run should not be improvising architecture: take §2's option (a), and use the mechanism this codebase already has three instances of — one op owns shared state, others read it through a non-owning pointer (overhang <- column source, ledge <- shaft source). FRoomGraphSource exposes LocalParamsAt(); detail ops read their fields from it. Same resolution as the pit/chimney "fiddliest thing in the decomposition": the difficulty came from assuming each op must own its params. Still off limits: build, editor, push, ticking bUseOperatorStack on an asset, and Phase 3. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
473bccb43f |
docs: handoff — add an unattended-run work queue for stage B
Jahni may start a session and leave, then have it shut the PC down. The successor still cannot build, so the section is about shaping ~680 lines of mechanical transcription for ONE informative build afterwards rather than pretending verification is available. Work queue B1-B5 (roughness / terrace-layerlines-ribbing / overhang-cliff- scallop-arch / columns-domes-pinch-floorbias / the bNearCaveSurface gate), one commit per group with the group named in the subject line, since Jahni reverts by group. Transcribe literally, note anything that looks wrong in the log and port it as-is anyway — that is how C1 and the MinDivisor split were both found without breaking anything. Records the subtlety that lets B precede C: the 13 modifiers read a copy of the params with the nearest room's op applied, so porting them against strate-level params is equivalent only while the test's room pool stays Pit/Chimney-only. Hard stops: do not flip TunnelNetwork or Underwater on, do not start stage C (design freedom without feedback), do not start the worm amplitude cap (it changes the fold contract all 13 tests rest on), do not build or push. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
b888b86729 |
docs: stage A verified with real coverage; rewrite the handoff
The run that matters: bit-identical over 6000 samples with 23.9% of them in open cave, and a bake carrying 49 rooms / 56 pits / 28 chimneys / 0 columns — so the pit and chimney loops finally ran on real data, and 0 columns confirms STEP 4d stayed dormant as stage A requires. Same code and same colour as the previous green run, three different strengths of evidence. That is the argument for printing coverage numbers rather than pass/fail. Handoff rewritten for a fresh context: the three-stage TunnelNetwork plan and why stage A is verifiable while incomplete, the calls-not-transcribes rule for BuildChunkCache, FRAME ops recorded as retired (0 of 3 candidates needed one), the per-room override reclassified as load-bearing rather than polish, and the method lessons regrouped around the three coverage traps. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
68e43238bd |
test: pits and chimneys never ran — ask the bake, not the density
Check 3b earned its keep on its first run: 0 of 1500 points moved when PitDensity was zeroed, because BuildChunkCache bakes pits inside `if (!CR.RoomOp) continue;` and then reads a FRESH param struct with only that room's terrain op applied. FStrateGenerationParams::PitDensity is never read by the bake. Pits, chimneys and columns exist only through a per-room UVoxelTerrainOpDefinition, and the fixture had none. Not a product bug: those fields carry no UPROPERTY, so no editor surface offers a setting that quietly does nothing. My reading was wrong. Three attempts, and the second is the instructive one. Zeroing the params tests fields nothing reads. Building a second stack with an empty op pool would have LIED — the op pool is not in the SDF cache key (LayoutVersion covers pool edits in production), so both stacks share the thread_local cache and report "no contribution" for a third wrong reason. So: ask the bake what it baked. Rooms > 0, pits > 0, chimneys > 0, columns == 0. The test now attaches a real Pit/Chimney op pool. Safe at stage A because ApplyTo(Pit) writes only pit fields, so none of the 13 unported detail modifiers wake up — a Terrace op there would break it, which is exactly what stage B adds. Also reworded the green equivalence message, which claimed pits and chimneys were exercised while zero existed. A success message that asserts coverage instead of reporting it reads as evidence while measuring nothing. Cave coverage 1.1% -> 21%, fingerprint 0.75% -> 95.8%. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
5bf61c1815 |
test: stage A is bit-identical — strengthen the test its own counters indicted
The port is correct across 6000 samples. The only failure was arithmetic in the assertion: 4 ops + 3 structural = 7, and I wrote 6. But two numbers that PASSED are the real finding. 65 of 6000 samples landed in open cave (1.1%), so the equivalence mostly compared solid rock to solid rock — the carve, pits, chimneys and worm carve only run near the network. And 3 of 400 probe points genuinely differed between the two param sets, so the stale-cache check asked its question three times and said "fine" 397 times about points that could never have answered it. Both counters were written to say exactly this, and did. Both guards only fired at ZERO, so the run went green with the coverage of a much smaller test. A coverage guard that only trips at zero does not measure coverage, it notices absence. Both are now fraction thresholds that print a percent. RoomSpacing 80 -> 42, RoomDensity 0.35 -> 0.85. New check 3b: rebuild the stack with PitDensity = ChimneyDensity = 0 and count the points that move. Enabling a feature in the params is not evidence it fired — SDFCache.Pits can come back empty and the test stays green — and these are the two loops DECOMPOSITION §2 calls the fiddliest in the plugin. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
ef5bda3d8a |
feat: TunnelNetwork stage A — the SDF spine, wrapping BuildChunkCache
The last archetype is ~1080 lines with 13 detail modifiers, a two-region cache and a per-room op override. Porting it whole before anything can be verified is ~600 unverified lines on top of ~200 — the pattern this refactor has dodged six times. So: three stages. Stage A = vertical scale, base rock, cave warp, room graph (+ pits and chimneys), carve, worms, structural post. 6 ops. It is verifiable NOW because every detail modifier is amplitude-gated and FStrateGenerationParams already defaults them all to zero — zeroing SurfaceRoughness sends the ORIGINAL down exactly the path stage A ported. TunnelNetwork stays OFF in UsesOperatorStackForChunk until stage C. The decision that matters: FRoomGraphSource CALLS BuildChunkCache and EvaluateSDFCached rather than transcribing them. That is where §8.4's two-region window-invariance discipline lives; a transcription would fork it, and the fork would be "validated" by a test comparing it to the original. Only the ~60 lines of glue are transcribed. FRAME ops are retired. All three candidates are now ported and none needed one: CaveWarp's scope is exactly one operator (pits/chimneys read unwarped coords), VerticalScale is a one-line pure function, and the island warp was already local. Not missing infrastructure — one idea seen three times from a distance. Also: check 3 was going to compare two interleaved param sets against the original, which would have FAILED — the original's SDF cache key has no params, so it serves B the rooms it built for A. Comparing there measures its bug, not the port. Rewritten against each stack evaluated alone. The same reasoning suggests a live production staleness across Gradient transitions; filed in AUDIT §C2 as SUSPECTED with the check that would confirm it, since it rests on a premise I have not verified. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
96e75abe57 |
feat: port FloatingIslands — the stack that runs backwards
6 of 8 archetypes ported. This one starts from VOID and FILLS where the other four start from ROCK and CARVE, which is what it was worth doing: neither end of the pile needed a new operator, only the opposite sign. FConstantRockSource -> FConstantFieldSource(+/-Base) AllSolid <-> AllAir FSdfCarveOp -> FSdfConvertOp(Sign = +/-1) carve <-> fill FSdfRoughnessMod 4th archetype, unchanged Only the island blob source is new. Multiplying by +/-1 is exact in IEEE-754, so the three already-green ports are bit-for-bit untouched. ClassifyBox can return AllAir for the first time in the plugin, and an island strate is by construction mostly empty — the test counts AllSolid and AllAir separately so an aggregate cannot hide whether that fired. Two bounds that would have been holes if assumed rather than derived: the island bound is one-sided (a hairline thread of matter hangs below each island down its axis, so only the TOP may reject), and the domain warp displaces X and Y independently, so the pad needs WarpAmp*sqrt(2). Also: AUDIT C1 was NOT closed. The 2026-07-27 sweep matched `SeedF * K` and this archetype's warp spells it `(float)S * K`, so one site survived — at seed 2e9 the warp flattens and every island snaps back to a perfect circle. Fixed in both paths in one pass so the equivalence test stays a valid oracle. Expect island silhouettes to change at large seeds. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
f5d5a03ad1 |
docs: end-of-day handoff — 5 of 8 ported, 11 tests green
Rewrites OPSTACK-HANDOFF.md for a fresh context: the port table, what is left in order, the two things Phase 2 invented that were not in the original design (height space as a second operator family, and IVoxelBiomeField so ops depend on a capability rather than the generator), and the method lessons that cost build cycles to learn. Open items, none blocking: perf (parked by Jahni), C9's library half (no measured risk), VerticalShafts' pessimistic box verdicts, and ClassifyTile still using hand-written guards while ClassifyBox sits verified but unconsumed — which is where the measured tile-skipping would actually become frames. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
d0a9ce3018 |
fix: the column key omitted the params — my perf fix broke the overhang
VerticalShaftEquivalence is bit-identical (966 samples inside a shaft), so operator
reuse across archetypes is measured now, not intended.
But SurfaceHeightEquivalence failed: 69/20000 overhang samples differ, 1 crossing the
isosurface. Cause is the ColumnKey from
|
||
|
Fr0zka
|
3acb3fbc6b |
feat: port VerticalShafts — three ops reused from Maze unchanged
The port that tests the thesis rather than the fidelity. Previous ports asked whether the decomposition reproduces the original; this one asks whether operators actually get reused across archetypes, which is section 2.5's claim and the only reason to do this refactor instead of tidying the switch. ConstantRock, SdfRoughness and SdfCarve are Maze's, reused without a line changed. In the switch, GetMazeDensity and GetVerticalShaftDensity are two ~100-line functions with nothing visibly in common; as operators they are the same three ops with a different source and different tuning (freq 0.1 vs 0.12, window rough+4 vs R+rough+2). New: FShaftFieldSource (infinite cylinders + hash-gated connectors into the SDF channel) and FShaftLedgeMod (banded shelves on the +X/+Y half so the shaft stays climbable). Deviation from section 6, stated: it suggested splitting the source so the XY-pure cylinder half could get an exact box verdict. Kept as one op because the connectors derive from the same 3x3 roll and the ledge mod needs the shaft list anyway, so splitting means rolling twice or sharing a cache between two ops. Forfeited: the exact verdict on the cylinder half. Kept: a conservative EffectOverBox testing circles and connector reach. FShaftLedgeMod gates on the POST-roughness Sdf as the stack left it; re-deriving it would use the pre-roughness value and shift every ledge. Reading the channel rather than recomputing is what the two-channel sample is for. Compile fix: FCells was declared below the functions returning it. Member bodies are deferred, return types are not. Ported: Maze, FlatPlain, CrystalChamber, SurfaceWorld (biomes included), VerticalShafts — 5 of 8. UNVERIFIED: not compiled past the FCells fix. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
Fr0zka
|
f3faa3b5c2 |
perf: the column memo threw itself away every chunk
Jahni measured what I had only flagged: generation is slower on the op-stack path. Two compounding causes. The memo was keyed on InstanceId, which changes on every stack rebuild — every chunk. GSurfColCache, the cache this path replaced, is keyed on (XY box, StrateKey, Seed, LayoutVersion) with no ChunkZ, deliberately shared down the whole vertical strate stack. So a 4-chunk strate recomputed every column four times, including the cliff's four extra structural samples per column. And the table held 256 entries where a chunk is CHUNK_SIZE^2 = 1024 columns, so it thrashed against itself within a single tile before any cross-chunk question arose. PrepareChunk now derives a shared ColumnKey from (StrateBottomWorldZ, LayoutVersion, Seed) — the same identity GSurfColCache uses — and the table is 4096 entries (~150 KB/worker, in line with GSurfColCache's 6 x 59 KB). The memo is thread_local so it already survived rebuilds; only the key was discarding the contents. Sharing across chunk Z is sound because heights are XY-pure by type and the biome field is documented Z-independent — the same justification GSurfColCache rests on. ColumnKey starts at InstanceId rather than 0: slots initialise to Key = 0, so a zero key would falsely hit the pristine slot at (0,0). Without PrepareChunk you get per-instance caching, which is less sharing but still correct. This may not close the gap entirely and I am not claiming it does. Virtual dispatch and the hashed lookup vs a direct-indexed box both remain; they are smaller than a 4x column recompute, but "smaller" is a guess until measured. UNVERIFIED: not compiled. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |