Add TubeField native replay validation

This commit is contained in:
Meta Vens 2026-05-29 22:42:54 +01:00
commit 5a0a7ec4e0
11 changed files with 246 additions and 42 deletions

View file

@ -349,15 +349,20 @@ Lane & Meaning \\
\end{tabular}
\end{center}
TubeField row-0 proposals write the selected subpixel UV, physical rolling
TubeField row-0 proposals write the selected subpixel UV, logical source
column, curve sample coordinate, tube-core support footprint, and explicit
motion shift kind when rolling-column replay is available. SDF scene proposals
reconstruct the current world hit, pack object-local coordinates, and mark the
sample as object-replayable. Reservoir validity now fails when a live sample
lacks domain state, and temporal/spatial validation multiplies the existing
field/travel/normal/confidence checks by support overlap in the selected-domain
lane. Debug modes expose selected coordinates, support footprint/domain kind,
and shift/rejection state from the same row-3 layer consumed by presentation.
motion shift kind when rolling-column replay is available. The field id still
uses physical rolling-column identity so age-column history cannot silently
cross-validate. SDF scene proposals reconstruct the current world hit, pack
object-local coordinates, and mark the sample as object-replayable. Reservoir
validity now fails when a live sample lacks domain state, and temporal/spatial
validation multiplies the existing field/travel/normal/confidence checks by
support overlap in the selected-domain lane. The first TubeField replay path
re-evaluates the selected logical column/curve coordinate against the live
producer buffer when exactly one TubeField replay batch is bound; ambiguous
multi-batch replay is invalid until a producer-keyed replay manifest exists.
Debug modes expose selected coordinates, support footprint/domain kind, and
shift/rejection state from the same row-3 layer consumed by presentation.
\section{Required Evaluation}

Binary file not shown.

View file

@ -547,10 +547,15 @@ metadata, control, guide, motion, domain sample, domain support, proposal, and
stats. The domain sample lane stores selected pixel/sample UV plus packed
producer coordinates; the domain support lane stores support footprint, domain
kind, and shift kind. TubeField proposals write selected subpixel UV,
physical rolling column, curve coordinate, tube support, and explicit motion
when available. SDF proposals reconstruct object-local hit coordinates and
mark object-motion replay. Temporal and spatial reuse now reject missing
domain state and include support overlap in the validation weight.
logical source column, curve coordinate, tube support, and explicit motion when
available. Field id still carries physical rolling-column identity. SDF
proposals reconstruct object-local hit coordinates and mark object-motion
replay. Temporal and spatial reuse now reject missing domain state and include
support overlap in the validation weight. The first TubeField replay path
also re-evaluates the shifted selected logical column/curve coordinate against
the live TubeField buffer when exactly one replay batch is bound. Multi-batch
TubeField replay remains invalid until a producer-keyed replay manifest maps
selected samples to the correct source buffer and constants.
\section{Reconstruction and Denoising}
@ -642,11 +647,12 @@ validated reservoirs. Neither mode lets a pixel row become truth.
\end{itemize}
The known architectural gap has moved forward: the current row ABI now carries
domain/sample-coordinate authority, but temporal reuse still needs full
producer re-evaluation after support overlap rather than treating overlap as
the whole legal shift story. The system has cut the false
``nearest-travel-minus-coverage'' priority owner and the side-cache temptation;
the next proof cut is producer-domain replay with measured rejection precision.
domain/sample-coordinate authority, and the first TubeField replay path
re-evaluates a selected logical column/curve coordinate in the current frame for
the single-batch proof case. The next proof cuts are SDF object-hit replay,
producer-keyed multi-batch replay manifests, and measured rejection precision.
The system has cut the false ``nearest-travel-minus-coverage'' priority owner
and the side-cache temptation.
\section{Evaluation Plan}

View file

@ -45,9 +45,11 @@ Fensalir already has the first shared GPU field-reservoir spine:
The surviving flaw has moved one layer downstream: the live ABI now stores
selected sample UV, packed producer coordinate, support footprint, domain kind,
and shift kind, and temporal/spatial validation uses support overlap. It still
needs producer-domain replay/re-evaluation before reuse can claim the full Area
ReSTIR proof rather than a first legal-overlap gate.
and shift kind, and temporal/spatial validation uses support overlap. TubeField
history can now re-evaluate a shifted selected logical column/curve coordinate
against the live producer buffer when exactly one TubeField replay batch is
bound. Multi-batch replay still needs a producer-keyed replay manifest before it
can claim authority.
## Invariants
@ -476,9 +478,12 @@ Work packet:
and shift kind.
5. Done: implement temporal/spatial support-overlap validation before further
threshold tuning.
6. Next: implement producer re-evaluation after the support-overlap gate for
TubeField rolling-column replay and SDF object-hit replay.
7. Capture the occluded-spectrum-tubes scene in baseline and native-domain
6. Partial: implement producer re-evaluation after the support-overlap gate for
TubeField rolling-column replay. The first path is intentionally limited to
one replay-bound TubeField batch; multi-batch replay is rejected until a
producer-keyed replay manifest exists.
7. Next: implement SDF object-hit replay/re-evaluation.
8. Capture the occluded-spectrum-tubes scene in baseline and native-domain
modes.
Required verification:

View file

@ -83,6 +83,8 @@ public sealed class D3D12Renderer : IAquariumRenderer
private const int RootBlueNoise = 18;
private const int RootFieldReservoirCandidates = 19;
private const int RootReservoirResolvedOutput = 20;
private const int RootTubeFieldReplayConstants = 21;
private const int RootTubeFieldReplaySource = 22;
private const int RootFusionFrameConstants = 0;
private const int RootFusionSeeds = 1;
private const int RootFusionSensorCameras = 2;
@ -2574,6 +2576,14 @@ public sealed class D3D12Renderer : IAquariumRenderer
historyReadBuffer.Transition(activeCommandList, ResourceStates.PixelShaderResource | ResourceStates.NonPixelShaderResource);
historyWriteBuffer.Transition(activeCommandList, ResourceStates.UnorderedAccess);
reservoirResolvedRenderTarget.Transition(activeCommandList, ResourceStates.UnorderedAccess);
var tubeFieldReplayBatch = tubeFieldDrawBatches.Count == 1 ? tubeFieldDrawBatches[0] : (D3D12TubeFieldDrawBatch?)null;
var tubeFieldReplayConstants = tubeFieldReplayBatch is not null
? tubeFieldReplayBatch.Value.ConstantsGpuVirtualAddress
: frameResources.UploadRing.WriteConstant(D3D12TubeFieldConstants.Disabled).GpuVirtualAddress;
var tubeFieldReplaySource = tubeFieldReplayBatch is not null
? tubeFieldReplayBatch.Value.Source
: tubeFieldStatsBuffer;
tubeFieldReplaySource.Transition(activeCommandList, ResourceStates.PixelShaderResource | ResourceStates.NonPixelShaderResource);
activeCommandList.SetDescriptorHeaps(frameResources.TransientShaderDescriptors.Heap);
activeCommandList.SetPipelineState(reservoirHistoryUpdatePipelineState);
@ -2587,6 +2597,8 @@ public sealed class D3D12Renderer : IAquariumRenderer
activeCommandList.SetComputeRootDescriptorTable(RootCurrentReservoirGuide, frameResources.SceneReservoirGuideDescriptor.Gpu);
activeCommandList.SetComputeRootShaderResourceView(RootFieldReservoirCandidates, fieldReservoirCandidateBuffer.Resource.GPUVirtualAddress);
activeCommandList.SetComputeRootDescriptorTable(RootReservoirResolvedOutput, frameResources.ReservoirResolvedUnorderedAccessDescriptor.Gpu);
activeCommandList.SetComputeRootConstantBufferView(RootTubeFieldReplayConstants, tubeFieldReplayConstants);
activeCommandList.SetComputeRootShaderResourceView(RootTubeFieldReplaySource, tubeFieldReplaySource.Resource.GPUVirtualAddress);
activeCommandList.Dispatch((uint)((width + 7) / 8), (uint)((height + 7) / 8), 1);
activeCommandList.ResourceBarrier(ResourceBarrier.BarrierUnorderedAccessView(historyWriteBuffer.Resource));
activeCommandList.ResourceBarrier(ResourceBarrier.BarrierUnorderedAccessView(reservoirResolvedRenderTarget.Resource));
@ -4392,6 +4404,8 @@ public sealed class D3D12Renderer : IAquariumRenderer
new RootParameter(new RootDescriptorTable([blueNoiseRange]), ShaderVisibility.Pixel),
new RootParameter(RootParameterType.ShaderResourceView, new RootDescriptor(45, 0), ShaderVisibility.All),
new RootParameter(new RootDescriptorTable([reservoirResolvedOutputRange]), ShaderVisibility.All),
new RootParameter(RootParameterType.ConstantBufferView, new RootDescriptor(3, 0), ShaderVisibility.All),
new RootParameter(RootParameterType.ShaderResourceView, new RootDescriptor(42, 0), ShaderVisibility.All),
};
var staticSamplers = new[]
{
@ -5130,7 +5144,22 @@ public sealed class D3D12Renderer : IAquariumRenderer
Vector3 AxisStep,
float Padding1,
Vector3 ColumnStep,
float Padding2);
float Padding2)
{
public static readonly D3D12TubeFieldConstants Disabled = new(
Vector4.Zero,
Vector4.Zero,
Vector4.Zero,
Vector4.Zero,
Vector4.Zero,
Vector4.Zero,
Vector3.Zero,
0.0f,
Vector3.Zero,
0.0f,
Vector3.Zero,
0.0f);
}
private sealed record D3D12ShaderPaths(
string HeightField,

View file

@ -27,6 +27,22 @@ cbuffer AquariumFrame : register(b0)
float4 cameraFrustumZ;
};
cbuffer TubeFieldReplayConstants : register(b3)
{
float4 tubeShape;
float4 tubeColumns;
float4 tubeAmplitude;
float4 tubeMaterial;
float4 tubeDispatch;
float4 tubeDraw;
float3 tubeOrigin;
float tubePadding0;
float3 tubeAxisStep;
float tubePadding1;
float3 tubeColumnStep;
float tubePadding2;
};
Texture2D<float4> sourceTexture : register(t0);
Texture2D<float4> currentSceneMetadataTexture : register(t5);
Texture2D<float4> currentSceneControlTexture : register(t7);
@ -40,6 +56,7 @@ Texture2D<float4> bloomTexture6 : register(t35);
Texture2D<float4> bloomTexture7 : register(t36);
Texture2D<float4> currentReservoirGuideTexture : register(t26);
Texture2D<float> blueNoiseTexture : register(t28);
ByteAddressBuffer tubeFieldReplaySamples : register(t42);
SamplerState sourceSampler : register(s0);
#include "D3D12Aces2.hlsl"
@ -165,6 +182,114 @@ float3 temporalPreviousWorldPosition(float3 worldPosition, float fieldId)
return worldPosition;
}
uint tubeReplayPositiveModulo(int value, uint modulo)
{
int m = (int)max(modulo, 1u);
int r = value % m;
return (uint)(r < 0 ? r + m : r);
}
uint tubeReplaySampleAddressWithOffset(uint logicalColumn, uint sampleIndex, int rollingOffset)
{
uint width = max((uint)round(tubeShape.x), 1u);
uint height = max((uint)round(tubeShape.y), 1u);
uint firstColumn = (uint)max(round(tubeShape.w), 0.0);
uint columnStride = max((uint)round(tubeColumns.y), 1u);
uint rollingModulo = (uint)max(round(tubeColumns.z), 0.0);
uint physicalColumn = firstColumn + logicalColumn * columnStride;
if (rollingModulo > 0u)
{
physicalColumn = tubeReplayPositiveModulo((int)physicalColumn + rollingOffset, rollingModulo);
}
physicalColumn = min(physicalColumn, height - 1u);
uint strideBytes = max((uint)round(tubeShape.z), 4u);
return (physicalColumn * width + min(sampleIndex, width - 1u)) * strideBytes;
}
float tubeReplayRawSampleWithOffset(uint logicalColumn, int sampleIndex, int rollingOffset)
{
uint width = max((uint)round(tubeShape.x), 1u);
uint clamped = (uint)clamp(sampleIndex, 0, (int)width - 1);
return asfloat(tubeFieldReplaySamples.Load(tubeReplaySampleAddressWithOffset(logicalColumn, clamped, rollingOffset)));
}
float tubeReplayFilteredSampleWithOffset(uint logicalColumn, float x, int rollingOffset)
{
int center = (int)floor(x + 0.5);
float s0 = tubeReplayRawSampleWithOffset(logicalColumn, center - 2, rollingOffset);
float s1 = tubeReplayRawSampleWithOffset(logicalColumn, center - 1, rollingOffset);
float s2 = tubeReplayRawSampleWithOffset(logicalColumn, center, rollingOffset);
float s3 = tubeReplayRawSampleWithOffset(logicalColumn, center + 1, rollingOffset);
float s4 = tubeReplayRawSampleWithOffset(logicalColumn, center + 2, rollingOffset);
return (s0 + s4 + 4.0 * (s1 + s3) + 6.0 * s2) / 16.0;
}
float tubeReplayCatmull(float p0, float p1, float p2, float p3, float t)
{
float t2 = t * t;
float t3 = t2 * t;
return 0.5 * ((2.0 * p1) +
(-p0 + p2) * t +
(2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t2 +
(-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
}
float tubeReplayNormalizedSampleWithOffset(uint logicalColumn, float x, int rollingOffset)
{
float value = tubeReplayFilteredSampleWithOffset(logicalColumn, x, rollingOffset);
return saturate((value - tubeAmplitude.z) / max(tubeAmplitude.w - tubeAmplitude.z, 0.0001));
}
float tubeReplaySampleCurve(uint logicalColumn, float x)
{
int i1 = (int)floor(x);
float t = frac(x);
float p0 = tubeReplayNormalizedSampleWithOffset(logicalColumn, (float)(i1 - 1), (int)round(tubeColumns.w));
float p1 = tubeReplayNormalizedSampleWithOffset(logicalColumn, (float)i1, (int)round(tubeColumns.w));
float p2 = tubeReplayNormalizedSampleWithOffset(logicalColumn, (float)(i1 + 1), (int)round(tubeColumns.w));
float p3 = tubeReplayNormalizedSampleWithOffset(logicalColumn, (float)(i1 + 2), (int)round(tubeColumns.w));
return saturate(tubeReplayCatmull(p0, p1, p2, p3, t));
}
bool tubeFieldReplayAvailableFor(FieldReservoirSample sample)
{
return tubeShape.x > 0.5 &&
sample.domainSupport.z > FieldDomainKindTube - 0.25 &&
sample.domainSupport.z < FieldDomainKindTube + 0.25 &&
sample.metadata.x >= tubeDraw.z &&
sample.metadata.x < tubeDraw.z + 50.0;
}
float tubeFieldReplayValidationWeight(FieldReservoirSample currentSample, FieldReservoirSample previousSample, uint2 pixel)
{
if (!tubeFieldReplayAvailableFor(currentSample) || !tubeFieldReplayAvailableFor(previousSample))
{
return 0.0;
}
uint columnCount = max((uint)round(tubeColumns.x), 1u);
uint logicalColumn = min((uint)max(round(previousSample.domainSample.z), 0.0), columnCount - 1u);
float sampleX = clamp(previousSample.domainSample.w, 0.0, max(tubeShape.x - 1.0, 0.0));
float value = tubeReplaySampleCurve(logicalColumn, sampleX);
float amplitude = pow(value, max(tubeAmplitude.x, 0.0001));
float3 replayWorld = tubeOrigin + tubeAxisStep * sampleX + tubeColumnStep * (float)logicalColumn + float3(0.0, amplitude * tubeAmplitude.y, 0.0);
float3 ray = rayDirectionForPixel((float2)pixel, jitterPixels, cameraPosition, cameraTarget);
float3 delta = replayWorld - cameraPosition;
float replayTravel = dot(delta, ray);
if (replayTravel <= 0.0 || replayTravel > farDistance)
{
return 0.0;
}
float rayDistance = length(delta - ray * replayTravel);
float radius = max(tubeMaterial.x + value * tubeMaterial.y, 0.0001);
float support = 1.0 - smoothstep(radius, radius + max(radius * 0.35, 0.01), rayDistance);
float travelTolerance = max(0.045, currentSample.colorTravel.w * 0.018);
float travelWeight = 1.0 - smoothstep(travelTolerance, travelTolerance * 4.0, abs(replayTravel - currentSample.colorTravel.w));
return support * travelWeight;
}
float2 projectWorldToPreviousHistoryUv(float3 worldPosition)
{
float3 forward;
@ -484,7 +609,10 @@ float reservoirTemporalValidationWeight(
float confidenceWeight = lerp(0.45, 1.0, min(reservoirSampleConfidence(currentSample), reservoirSampleConfidence(previousSample)));
float domainWeight = reservoirSampleDomainValidity(currentSample) * reservoirSampleDomainValidity(previousSample);
float supportOverlap = fieldReservoirDomainSupportOverlap(currentSample, previousSample, dimensions);
return travelWeight * fieldWeight * normalWeight * colorWeight * coverageWeight * coverageContinuityWeight * detailWeight * confidenceWeight * domainWeight * supportOverlap;
float replayWeight = fieldReservoirSampleRequiresExplicitMotion(currentSample)
? tubeFieldReplayValidationWeight(currentSample, previousSample, (uint2)pixelFromUv(currentSample.domainSample.xy))
: 1.0;
return travelWeight * fieldWeight * normalWeight * colorWeight * coverageWeight * coverageContinuityWeight * detailWeight * confidenceWeight * domainWeight * supportOverlap * replayWeight;
}
float reservoirTemporalRejectionCode(
@ -524,6 +652,12 @@ float reservoirTemporalRejectionCode(
return 8.0;
}
if (fieldReservoirSampleRequiresExplicitMotion(currentSample) &&
tubeFieldReplayValidationWeight(currentSample, previousSample, (uint2)pixelFromUv(currentSample.domainSample.xy)) <= 0.0)
{
return 9.0;
}
return 1.0;
}
@ -713,10 +847,22 @@ float4 reservoirDebugOrColor(FieldReservoirSample candidate)
{
color = float3(0.0, 1.0, 1.0);
}
else
else if (invalidation < 6.5)
{
color = float3(0.9, 0.0, 1.0);
}
else if (invalidation < 7.5)
{
color = float3(1.0, 0.35, 0.0);
}
else if (invalidation < 8.5)
{
color = float3(0.5, 0.15, 1.0);
}
else
{
color = float3(1.0, 0.0, 0.25);
}
return float4(color, candidate.colorTravel.w);
}

View file

@ -879,7 +879,7 @@ SceneOut D3D12TubeFieldPS(TubeFieldVertexOut input)
output.reservoirGuide = float4(claimCoverage, 0.0, supportCoverage, value);
output.depth = saturate(travel / max(farDistance, 0.0001));
float target = fieldReservoirDefaultTarget(output.colorTravel, output.control, output.reservoirGuide);
float selectedColumn = (float)PhysicalColumnWithOffset((uint)round(input.tubeData.x), currentRollingOffset);
float selectedColumn = round(input.tubeData.x);
float2 selectedUv = (baseSamplePx + 0.5) / max(resolution, float2(1.0, 1.0));
float2 selectedProducerCoord = float2(selectedColumn, sampleX);
float2 supportFootprintPx = max(float2(baseRadiusPx, baseRadiusPx), float2(0.5, 0.5));

View file

@ -293,3 +293,4 @@
{"timestamp":"2026-05-29T21:10:00+01:00","topic":"siggraph-core-paper-reorientation","lesson":"SIGGRAPH framing should not sell the whole Perfect Machine as one paper. The focused technical claim is native-domain reservoir state for mixed TubeField/SDF/splat reuse: selected producer-domain coordinate, support footprint, proposal measure, target value, and legal shift metadata should reduce leakage/ghosting compared with texel-owned reuse. The broad pipeline paper remains architecture context; the focused paper names required scenes, baselines, ablations, metrics, and current prototype debug captures, and explicitly does not claim final results until those proof obligations are paid.","files":["docs/papers/fensalir-native-domain-reservoirs.tex","docs/papers/fensalir-native-domain-reservoirs.pdf","docs/README.md"],"sources":["user SIGGRAPH-hat review","docs/papers/fensalir-pipeline.tex","docs/fractal-domain-reservoir.md","docs/temporal-spatial-evidence-reservoir.md"]}
{"timestamp":"2026-05-29T21:35:00+01:00","topic":"perfect-fensalir-machine-roadmap","lesson":"The Perfect Fensalir Machine roadmap now makes the native-domain reservoir proof the first implementation gate. The immediate work packet is to add or repack FieldReservoirSample so TubeField and SDF row-0 proposals carry selected domain/sample coordinates and support, expose support/shift debug views, and validate temporal reuse by support overlap before more occlusion-threshold tuning. Broader fractal hierarchy, residency, sensor/flow, and learned-priority work waits behind the evaluated mixed-field proof.","files":["docs/perfect-fensalir-machine-roadmap.md","docs/README.md","state/scratch.md","state/map.yaml"],"sources":["docs/fractal-domain-reservoir.md","docs/papers/fensalir-native-domain-reservoirs.tex","docs/reservoir-reconstruction-action-plan.md","user requested synthesis into implementation roadmap"]}
{"timestamp":"2026-05-29T22:23:11+01:00","topic":"native-domain-reservoir-abi","lesson":"FieldReservoirSample is now a nine-lane native-domain reservoir row: colorTravel, metadata, control, guide, motion, domainSample, domainSupport, proposal, and stats. TubeField proposals write selected subpixel UV, physical rolling column, curve coordinate, tube support footprint, and shift kind; SDF proposals reconstruct object-local hit coordinates. Reservoir validity rejects missing domain state, temporal/spatial reuse includes support overlap, and debug modes 16-18 expose domain coordinate, support/domain kind, and shift state. The next proof cut is producer re-evaluation after support overlap, not another occlusion threshold.","files":["src/Aquarium.Engine/Render/Shaders/D3D12FieldReservoir.hlsli","src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl","src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl","src/Aquarium.Engine/Render/D3D12Renderer.cs","src/Aquarium.Engine.Contracts/GraphicsSettings.cs","tests/Aquarium.Engine.Tests/FieldReservoirAbiTests.cs","docs/papers/fensalir-native-domain-reservoirs.tex","docs/papers/fensalir-pipeline.tex","docs/perfect-fensalir-machine-roadmap.md","state/map.yaml","state/scratch.md"],"sources":["docs/perfect-fensalir-machine-roadmap.md"]}
{"timestamp":"2026-05-29T22:42:00+01:00","topic":"tubefield-single-batch-replay","lesson":"TubeField native-domain replay now uses logical source column plus curve coordinate as the selected producer coordinate while field id retains physical rolling-column identity. The reservoir history compute pass receives a TubeField replay source/constants binding only when exactly one TubeField batch exists, then re-evaluates the shifted selected sample against the live producer buffer before temporal merge. Multi-batch TubeField replay is intentionally invalid until a producer-keyed replay manifest maps selected samples to source buffers and constants; do not fill that gap with a side cache.","files":["src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl","src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl","src/Aquarium.Engine/Render/D3D12Renderer.cs","docs/perfect-fensalir-machine-roadmap.md","docs/papers/fensalir-native-domain-reservoirs.tex","docs/papers/fensalir-pipeline.tex","state/map.yaml","state/scratch.md"],"sources":["docs/perfect-fensalir-machine-roadmap.md"]}

View file

@ -128,11 +128,13 @@ next_actions:
residency, and learned-priority work waits behind that gate.
- Cut the rendering rebuild through explicit field-domain/field-claim
contracts before adding another backend-specific visual path.
- Before more occlusion-threshold tuning, extend the first native-domain ABI
cut into producer replay/re-evaluation. TubeField and SDF proposals now
include selected domain/sample-coordinate and support data, and reuse
validates support overlap; the next cut is to re-evaluate the shifted
TubeField/SDF sample in the target domain before merge.
- Before more occlusion-threshold tuning, extend native-domain replay beyond
the first TubeField proof path. TubeField and SDF proposals now include
selected domain/sample-coordinate and support data, reuse validates support
overlap, and single-batch TubeField history re-evaluates the shifted logical
column/curve coordinate against the live producer buffer. The next cuts are
SDF replay and a producer-keyed replay manifest for multi-batch TubeField
reuse.
- Build the planetary flow organ in staged cuts: provenance manifest, static
relief and reanalysis cube-sphere bake pipeline, stochastic advection
contracts, synthetic runtime slice, ERA5/OSCAR baseline learning, then
@ -276,15 +278,19 @@ next_actions:
TubeField now writes a one-sample reservoir proposal into row 0 with target
derived from projected coverage, guide confidence, and luminance relevance;
sourcePdf is 1.0 for deterministic structural proposals. TubeField row-0
proposals also write selected subpixel UV, physical rolling column, curve
proposals also write selected subpixel UV, logical source column, curve
coordinate, tube support footprint, and explicit motion shift kind when
available; SDF scene proposals reconstruct object-local hit coordinates and
mark object-motion replay. The old nearest-travel-minus-coverage priority
available; field id still carries physical rolling-column identity. SDF
scene proposals reconstruct object-local hit coordinates and mark
object-motion replay. The old nearest-travel-minus-coverage priority
authority is cut from both TubeField injection and final resolve. Shared
temporal reuse validates only the previous frame's row-3 final reservoir by
field id, travel, normal, domain validity, motion/previous UV, guide
confidence, and support overlap before RIS merge; rejected history cannot
become visible fallback by itself. Spatial reuse validates neighboring
confidence, support overlap, and single-batch TubeField producer
re-evaluation before RIS merge; rejected history cannot become visible
fallback by itself. Multi-batch TubeField replay is invalid until a
producer-keyed replay manifest maps selected samples to their source buffer
and constants. Spatial reuse validates neighboring
current reservoirs by field id, travel, normal, support overlap, and domain
before merge. Current-frame structural proposal assembly has a
visibility gate before RIS: if two valid proposals at the same pixel differ

View file

@ -2,8 +2,8 @@
## Current Slice
Extend the first Perfect Fensalir Machine reservoir cut from native-domain row
state into producer-domain replay/re-evaluation.
Extend native-domain reservoir replay from the first single-batch TubeField
proof path into SDF replay and producer-keyed multi-batch replay.
## Hot Lesson
@ -17,14 +17,20 @@ semantic domains and a dynamic contribution tree into bounded GPU reservoirs.
The current nine-lane row ABI now carries first-class selected
domain/sample-coordinate authority. A row keyed only by pixel, travel, field id,
guide, proposal, and stats is no longer accepted as valid reservoir evidence.
TubeField row samples store selected UV, logical column, curve coordinate,
support footprint, domain kind, and shift kind; field id carries physical
rolling-column identity. The history pass can bind exactly one TubeField replay
batch and re-evaluate shifted TubeField history against that live source buffer.
Multiple TubeField batches are intentionally not replay-authoritative yet.
## Next Bounded Move
Follow `docs/perfect-fensalir-machine-roadmap.md` Phase 1:
1. Implement producer re-evaluation after the support-overlap gate for
TubeField rolling-column replay.
2. Implement SDF object-hit replay/re-evaluation for shifted history.
1. Implement SDF object-hit replay/re-evaluation for shifted history.
2. Add a producer-keyed TubeField replay manifest so multi-batch TubeField
history can bind the correct source buffer/constants instead of being
rejected.
3. Capture the occluded-spectrum-tubes scene in baseline/native-domain modes
after replay is real, not merely support-overlap filtered.