diff --git a/docs/papers/fensalir-native-domain-reservoirs.pdf b/docs/papers/fensalir-native-domain-reservoirs.pdf index c4bfbf3..b598819 100644 Binary files a/docs/papers/fensalir-native-domain-reservoirs.pdf and b/docs/papers/fensalir-native-domain-reservoirs.pdf differ diff --git a/docs/papers/fensalir-native-domain-reservoirs.tex b/docs/papers/fensalir-native-domain-reservoirs.tex index 7125915..3e95c96 100644 --- a/docs/papers/fensalir-native-domain-reservoirs.tex +++ b/docs/papers/fensalir-native-domain-reservoirs.tex @@ -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} diff --git a/docs/papers/fensalir-pipeline.pdf b/docs/papers/fensalir-pipeline.pdf index 8677595..7e73f23 100644 Binary files a/docs/papers/fensalir-pipeline.pdf and b/docs/papers/fensalir-pipeline.pdf differ diff --git a/docs/papers/fensalir-pipeline.tex b/docs/papers/fensalir-pipeline.tex index 449abb8..1fe5588 100644 --- a/docs/papers/fensalir-pipeline.tex +++ b/docs/papers/fensalir-pipeline.tex @@ -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} diff --git a/docs/perfect-fensalir-machine-roadmap.md b/docs/perfect-fensalir-machine-roadmap.md index 793e5d2..cd8d2dd 100644 --- a/docs/perfect-fensalir-machine-roadmap.md +++ b/docs/perfect-fensalir-machine-roadmap.md @@ -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: diff --git a/src/Aquarium.Engine/Render/D3D12Renderer.cs b/src/Aquarium.Engine/Render/D3D12Renderer.cs index 36c18b3..eabd7a7 100644 --- a/src/Aquarium.Engine/Render/D3D12Renderer.cs +++ b/src/Aquarium.Engine/Render/D3D12Renderer.cs @@ -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, diff --git a/src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl b/src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl index 57c940d..f0d02df 100644 --- a/src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl +++ b/src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl @@ -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 sourceTexture : register(t0); Texture2D currentSceneMetadataTexture : register(t5); Texture2D currentSceneControlTexture : register(t7); @@ -40,6 +56,7 @@ Texture2D bloomTexture6 : register(t35); Texture2D bloomTexture7 : register(t36); Texture2D currentReservoirGuideTexture : register(t26); Texture2D 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); } diff --git a/src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl b/src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl index 4c097be..7807e11 100644 --- a/src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl +++ b/src/Aquarium.Engine/Render/Shaders/D3D12TubeField.hlsl @@ -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)); diff --git a/state/evidence.jsonl b/state/evidence.jsonl index c389bce..433e144 100644 --- a/state/evidence.jsonl +++ b/state/evidence.jsonl @@ -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"]} diff --git a/state/map.yaml b/state/map.yaml index 3b7172d..154d3a9 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -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 diff --git a/state/scratch.md b/state/scratch.md index eb25576..0c78edb 100644 --- a/state/scratch.md +++ b/state/scratch.md @@ -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.