Extract temporal spatial evidence reservoir

This commit is contained in:
Meta Vens 2026-05-19 13:40:52 +01:00
commit 7fbff66f7b
9 changed files with 391 additions and 123 deletions

View file

@ -16,14 +16,22 @@ center, velocity, oriented radii, color/opacity, confidence, history weight,
compact-kernel controls, and field id.
`Aquarium.Engine.Fractal.Temporal.TemporalGaussianAccumulator` consumes
`TemporalGaussianObservation` rows and owns the live buffering policy:
`TemporalGaussianObservation` rows and lowers them through the shared
`TemporalSpatialEvidenceReservoir`. The reservoir owns the live buffering
policy:
- stable keys identify tracks across camera/sensor frames
- presentation delay lets late sensor data converge before rendering
- accumulation window expires old tracks
- max-track budgets evict low-confidence stale tracks before renderer lowering
- smoothed velocity predicts the presented center
- history weight is confidence scaled by age inside the window
The Gaussian field is one backend for this reservoir, not the reservoir's
identity. Fractal SDF probes, visual point-cloud features, and future acoustic
constraints can all enter as stable keyed spatial evidence as long as each
producer declares confidence, time, bounds, and payload lowering rules.
The D3D12 renderer lowers the field into `D3D12TemporalGaussianPacket`, uploads
the active packet span into a 1,048,576-entry structured buffer, and renders an
instanced proxy-quad pass from

View file

@ -5,7 +5,7 @@ namespace Aquarium.Engine.Fractal.Temporal;
public sealed class TemporalGaussianAccumulator
{
private readonly Dictionary<string, TemporalGaussianTrack> tracks = [];
private readonly TemporalSpatialEvidenceReservoir reservoir;
public TemporalGaussianAccumulator(
float accumulationWindowSeconds,
@ -27,145 +27,62 @@ public sealed class TemporalGaussianAccumulator
throw new ArgumentOutOfRangeException(nameof(smoothing), smoothing, "Smoothing must be in (0, 1].");
}
AccumulationWindowSeconds = accumulationWindowSeconds;
PresentationDelaySeconds = presentationDelaySeconds;
Smoothing = smoothing;
reservoir = new TemporalSpatialEvidenceReservoir(accumulationWindowSeconds, presentationDelaySeconds, smoothing);
}
public float AccumulationWindowSeconds { get; }
public float AccumulationWindowSeconds => reservoir.AccumulationWindowSeconds;
public float PresentationDelaySeconds { get; }
public float PresentationDelaySeconds => reservoir.PresentationDelaySeconds;
public float Smoothing { get; }
public float Smoothing => reservoir.Smoothing;
public void Observe(IEnumerable<TemporalGaussianObservation> observations)
{
foreach (var observation in observations)
{
if (string.IsNullOrWhiteSpace(observation.StableKey))
{
continue;
}
if (tracks.TryGetValue(observation.StableKey, out var current))
{
tracks[observation.StableKey] = current.Update(observation, Smoothing);
}
else
{
tracks[observation.StableKey] = TemporalGaussianTrack.Create(observation);
}
}
reservoir.Observe(observations.Select(observation => new TemporalSpatialEvidenceObservation(
observation.StableKey,
observation.Center,
observation.Radii,
observation.Orientation,
observation.ColorOpacity,
new Vector4(
MathF.Max(0.0001f, observation.Falloff),
MathF.Max(0.0001f, observation.ShapePower),
0.0f,
0.0f),
observation.Confidence,
observation.ObservedTimeSeconds,
observation.FieldId)));
}
public AquariumTemporalGaussianField BuildField(float renderTimeSeconds)
{
var presentationTime = renderTimeSeconds - PresentationDelaySeconds;
var cutoff = presentationTime - AccumulationWindowSeconds;
var gaussians = new List<AquariumTemporalSdfGaussian>(tracks.Count);
var expired = new List<string>();
var snapshot = reservoir.BuildSnapshot(renderTimeSeconds);
var gaussians = new AquariumTemporalSdfGaussian[snapshot.Samples.Count];
foreach (var (key, track) in tracks)
for (var index = 0; index < snapshot.Samples.Count; index++)
{
if (track.LastObservedTimeSeconds < cutoff)
{
expired.Add(key);
continue;
}
var age = MathF.Max(0.0f, presentationTime - track.LastObservedTimeSeconds);
var historyWeight = Math.Clamp(1.0f - (age / AccumulationWindowSeconds), 0.0f, 1.0f) * track.Confidence;
var predictedCenter = track.Center + track.Velocity * (presentationTime - track.LastObservedTimeSeconds);
var previousCenter = predictedCenter - track.Velocity * (1.0f / 60.0f);
gaussians.Add(new AquariumTemporalSdfGaussian(
track.StableKey,
predictedCenter,
previousCenter,
track.Velocity,
track.Radii,
track.Orientation,
track.ColorOpacity,
track.Confidence,
historyWeight,
track.LastObservedTimeSeconds,
track.Falloff,
track.ShapePower,
track.FieldId));
}
foreach (var key in expired)
{
tracks.Remove(key);
var sample = snapshot.Samples[index];
gaussians[index] = new AquariumTemporalSdfGaussian(
sample.StableKey,
sample.Center,
sample.PreviousCenter,
sample.Velocity,
sample.Radii,
sample.Orientation,
sample.Payload0,
sample.Confidence,
sample.HistoryWeight,
sample.LastObservedTimeSeconds,
sample.Payload1.X,
sample.Payload1.Y,
sample.FieldId);
}
return new AquariumTemporalGaussianField
{
Gaussians = gaussians.OrderByDescending(item => item.HistoryWeight).ToArray(),
Gaussians = gaussians,
AccumulationWindowSeconds = AccumulationWindowSeconds,
PresentationDelaySeconds = PresentationDelaySeconds,
};
}
private readonly record struct TemporalGaussianTrack(
string StableKey,
Vector3 Center,
Vector3 Velocity,
Vector3 Radii,
Quaternion Orientation,
Vector4 ColorOpacity,
float Confidence,
float LastObservedTimeSeconds,
float Falloff,
float ShapePower,
int FieldId)
{
public static TemporalGaussianTrack Create(TemporalGaussianObservation observation)
{
return new TemporalGaussianTrack(
observation.StableKey,
observation.Center,
Vector3.Zero,
SanitizeRadii(observation.Radii),
SanitizeOrientation(observation.Orientation),
observation.ColorOpacity,
Math.Clamp(observation.Confidence, 0.0f, 1.0f),
observation.ObservedTimeSeconds,
MathF.Max(0.0001f, observation.Falloff),
MathF.Max(0.0001f, observation.ShapePower),
observation.FieldId);
}
public TemporalGaussianTrack Update(TemporalGaussianObservation observation, float smoothing)
{
var dt = MathF.Max(0.0001f, observation.ObservedTimeSeconds - LastObservedTimeSeconds);
var measuredVelocity = (observation.Center - Center) / dt;
var alpha = smoothing * Math.Clamp(observation.Confidence, 0.0f, 1.0f);
var updatedCenter = Vector3.Lerp(Center, observation.Center, alpha);
return this with
{
Center = updatedCenter,
Velocity = Vector3.Lerp(Velocity, measuredVelocity, alpha),
Radii = Vector3.Lerp(Radii, SanitizeRadii(observation.Radii), alpha),
Orientation = SanitizeOrientation(Quaternion.Slerp(Orientation, SanitizeOrientation(observation.Orientation), alpha)),
ColorOpacity = Vector4.Lerp(ColorOpacity, observation.ColorOpacity, alpha),
Confidence = Math.Clamp((Confidence * 0.85f) + (observation.Confidence * 0.15f), 0.0f, 1.0f),
LastObservedTimeSeconds = observation.ObservedTimeSeconds,
Falloff = MathF.Max(0.0001f, observation.Falloff),
ShapePower = MathF.Max(0.0001f, observation.ShapePower),
FieldId = observation.FieldId,
};
}
private static Vector3 SanitizeRadii(Vector3 radii)
{
return Vector3.Max(radii, new Vector3(0.0001f));
}
private static Quaternion SanitizeOrientation(Quaternion orientation)
{
return orientation.LengthSquared() <= 0.000001f
? Quaternion.Identity
: Quaternion.Normalize(orientation);
}
}
}

View file

@ -0,0 +1,47 @@
using System.Numerics;
namespace Aquarium.Engine.Fractal.Temporal;
public readonly record struct TemporalSpatialEvidenceObservation(
string StableKey,
Vector3 Center,
Vector3 Radii,
Quaternion Orientation,
Vector4 Payload0,
Vector4 Payload1,
float Confidence,
float ObservedTimeSeconds,
int FieldId = 0);
public readonly record struct TemporalSpatialEvidenceSample(
string StableKey,
Vector3 Center,
Vector3 PreviousCenter,
Vector3 Velocity,
Vector3 Radii,
Quaternion Orientation,
Vector4 Payload0,
Vector4 Payload1,
float Confidence,
float HistoryWeight,
float LastObservedTimeSeconds,
int FieldId);
public sealed class TemporalSpatialEvidenceSnapshot
{
public TemporalSpatialEvidenceSnapshot(
IReadOnlyList<TemporalSpatialEvidenceSample> samples,
float accumulationWindowSeconds,
float presentationDelaySeconds)
{
Samples = samples;
AccumulationWindowSeconds = accumulationWindowSeconds;
PresentationDelaySeconds = presentationDelaySeconds;
}
public IReadOnlyList<TemporalSpatialEvidenceSample> Samples { get; }
public float AccumulationWindowSeconds { get; }
public float PresentationDelaySeconds { get; }
}

View file

@ -0,0 +1,195 @@
using System.Numerics;
namespace Aquarium.Engine.Fractal.Temporal;
public sealed class TemporalSpatialEvidenceReservoir
{
private readonly Dictionary<string, TemporalSpatialEvidenceTrack> tracks = [];
public TemporalSpatialEvidenceReservoir(
float accumulationWindowSeconds,
float presentationDelaySeconds,
float smoothing = 0.35f,
int maxTrackCount = int.MaxValue)
{
if (!float.IsFinite(accumulationWindowSeconds) || accumulationWindowSeconds <= 0.0f)
{
throw new ArgumentOutOfRangeException(nameof(accumulationWindowSeconds), accumulationWindowSeconds, "Accumulation window must be positive.");
}
if (!float.IsFinite(presentationDelaySeconds) || presentationDelaySeconds < 0.0f)
{
throw new ArgumentOutOfRangeException(nameof(presentationDelaySeconds), presentationDelaySeconds, "Presentation delay must be non-negative.");
}
if (!float.IsFinite(smoothing) || smoothing <= 0.0f || smoothing > 1.0f)
{
throw new ArgumentOutOfRangeException(nameof(smoothing), smoothing, "Smoothing must be in (0, 1].");
}
if (maxTrackCount <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxTrackCount), maxTrackCount, "Track budget must be positive.");
}
AccumulationWindowSeconds = accumulationWindowSeconds;
PresentationDelaySeconds = presentationDelaySeconds;
Smoothing = smoothing;
MaxTrackCount = maxTrackCount;
}
public float AccumulationWindowSeconds { get; }
public float PresentationDelaySeconds { get; }
public float Smoothing { get; }
public int MaxTrackCount { get; }
public void Observe(IEnumerable<TemporalSpatialEvidenceObservation> observations)
{
foreach (var observation in observations)
{
if (string.IsNullOrWhiteSpace(observation.StableKey))
{
continue;
}
if (tracks.TryGetValue(observation.StableKey, out var current))
{
tracks[observation.StableKey] = current.Update(observation, Smoothing);
}
else
{
tracks[observation.StableKey] = TemporalSpatialEvidenceTrack.Create(observation);
}
}
TrimToBudget();
}
public TemporalSpatialEvidenceSnapshot BuildSnapshot(float renderTimeSeconds)
{
var presentationTime = renderTimeSeconds - PresentationDelaySeconds;
var cutoff = presentationTime - AccumulationWindowSeconds;
var samples = new List<TemporalSpatialEvidenceSample>(tracks.Count);
var expired = new List<string>();
foreach (var (key, track) in tracks)
{
if (track.LastObservedTimeSeconds < cutoff)
{
expired.Add(key);
continue;
}
var age = MathF.Max(0.0f, presentationTime - track.LastObservedTimeSeconds);
var historyWeight = Math.Clamp(1.0f - (age / AccumulationWindowSeconds), 0.0f, 1.0f) * track.Confidence;
var predictedCenter = track.Center + track.Velocity * (presentationTime - track.LastObservedTimeSeconds);
var previousCenter = predictedCenter - track.Velocity * (1.0f / 60.0f);
samples.Add(new TemporalSpatialEvidenceSample(
track.StableKey,
predictedCenter,
previousCenter,
track.Velocity,
track.Radii,
track.Orientation,
track.Payload0,
track.Payload1,
track.Confidence,
historyWeight,
track.LastObservedTimeSeconds,
track.FieldId));
}
foreach (var key in expired)
{
tracks.Remove(key);
}
return new TemporalSpatialEvidenceSnapshot(
samples.OrderByDescending(item => item.HistoryWeight).ToArray(),
AccumulationWindowSeconds,
PresentationDelaySeconds);
}
private void TrimToBudget()
{
if (tracks.Count <= MaxTrackCount)
{
return;
}
var evict = tracks.Values
.OrderBy(track => track.Confidence)
.ThenBy(track => track.LastObservedTimeSeconds)
.Take(tracks.Count - MaxTrackCount)
.Select(track => track.StableKey)
.ToArray();
foreach (var key in evict)
{
tracks.Remove(key);
}
}
private readonly record struct TemporalSpatialEvidenceTrack(
string StableKey,
Vector3 Center,
Vector3 Velocity,
Vector3 Radii,
Quaternion Orientation,
Vector4 Payload0,
Vector4 Payload1,
float Confidence,
float LastObservedTimeSeconds,
int FieldId)
{
public static TemporalSpatialEvidenceTrack Create(TemporalSpatialEvidenceObservation observation)
{
return new TemporalSpatialEvidenceTrack(
observation.StableKey,
observation.Center,
Vector3.Zero,
SanitizeRadii(observation.Radii),
SanitizeOrientation(observation.Orientation),
observation.Payload0,
observation.Payload1,
Math.Clamp(observation.Confidence, 0.0f, 1.0f),
observation.ObservedTimeSeconds,
observation.FieldId);
}
public TemporalSpatialEvidenceTrack Update(TemporalSpatialEvidenceObservation observation, float smoothing)
{
var dt = MathF.Max(0.0001f, observation.ObservedTimeSeconds - LastObservedTimeSeconds);
var measuredVelocity = (observation.Center - Center) / dt;
var alpha = smoothing * Math.Clamp(observation.Confidence, 0.0f, 1.0f);
var updatedCenter = Vector3.Lerp(Center, observation.Center, alpha);
return this with
{
Center = updatedCenter,
Velocity = Vector3.Lerp(Velocity, measuredVelocity, alpha),
Radii = Vector3.Lerp(Radii, SanitizeRadii(observation.Radii), alpha),
Orientation = SanitizeOrientation(Quaternion.Slerp(Orientation, SanitizeOrientation(observation.Orientation), alpha)),
Payload0 = Vector4.Lerp(Payload0, observation.Payload0, alpha),
Payload1 = Vector4.Lerp(Payload1, observation.Payload1, alpha),
Confidence = Math.Clamp((Confidence * 0.85f) + (observation.Confidence * 0.15f), 0.0f, 1.0f),
LastObservedTimeSeconds = observation.ObservedTimeSeconds,
FieldId = observation.FieldId,
};
}
private static Vector3 SanitizeRadii(Vector3 radii)
{
return Vector3.Max(radii, new Vector3(0.0001f));
}
private static Quaternion SanitizeOrientation(Quaternion orientation)
{
return orientation.LengthSquared() <= 0.000001f
? Quaternion.Identity
: Quaternion.Normalize(orientation);
}
}
}

View file

@ -150,3 +150,4 @@
{"timestamp":"2026-05-18T12:22:00+01:00","topic":"fractal-temporal-detail-control","lesson":"Fractal cache influence now has a first TAA-facing lane. SdfSurface carries temporalDetail, SDF proxy writes it into scene-control.z, D3D12Post validates history continuity against the current and previous temporalDetail signal, and history-control.z preserves it across frames. Zyphos feeds this from authored cube-face brush material influence; other SDFs explicitly emit zero until they gain cache-owned detail.","files":["src/Aquarium.Engine/Render/Shaders/D3D12SdfCommon.hlsli","src/Aquarium.Engine/Render/Shaders/D3D12SdfProxy.hlsli","src/Aquarium.Engine/Render/Shaders/D3D12Post.hlsl","src/Aquarium.Zyphos/Shaders/D3D12ZyphosPlanet.hlsl","src/Aquarium.Epiphany/Shaders"],"source":"user said to weave the stochastic fractal cache into TAA buffers"}
{"timestamp":"2026-05-18T18:09:50+01:00","topic":"temporal-sdf-gaussian-renderer-boundary","lesson":"Live sensor-fusion splats now enter Aquarium through an engine-owned temporal SDF Gaussian field instead of client-side renderer folklore. The contract carries stable keyed world-space Gaussians; `TemporalGaussianAccumulator` buffers observations with presentation delay and history weights; D3D12 uploads structured packets and renders an instanced compact-kernel splat pass into the existing scene/metadata/control targets. Scaling beyond 4096 splats belongs to Aquarium residency/binning, not LocalCastBridge.","files":["src/Aquarium.Engine.Contracts/Render/AquariumRenderPlan.cs","src/Aquarium.Engine.Fractal/Temporal/TemporalGaussianAccumulator.cs","src/Aquarium.Engine/Render/Shaders/D3D12TemporalGaussian.hlsl","src/Aquarium.Engine/Render/D3D12Renderer.cs","docs/temporal-sdf-gaussian-field.md"],"source":"user directed the point-cloud/TAA renderer feature to be implemented on the Aquarium side for clean client consumption"}
{"timestamp":"2026-05-19T13:38:00+01:00","topic":"fractal-resource-budget-and-flame-dsl","lesson":"The fractal DSL now has a compact `flame` primitive for deterministic curled recursive brush emission, and Zyphos exercises it in a leaf microdetail domain without exceeding the 64-brush stress table. Fractal render planning now coordinates CPU stochastic update count, GPU selected-cut estimated cost, RAM resident payload budget, and SSD request budget before packet compilation. This budget vocabulary should remain compatible with Mimir-style sensor fusion because both pipelines accumulate confidence-weighted spatial samples into temporal reservoirs before rendering a resolved field.","files":["src/Aquarium.Engine.Fractal/Grammar/FractalDslCompiler.cs","src/Aquarium.Engine.Fractal/Lod/FractalResourceBudget.cs","src/Aquarium.Engine.Fractal/Lod/FractalResourceBudgetPlanner.cs","src/Aquarium.Engine.Fractal/Lod/FractalResidencyPlanner.cs","src/Aquarium.Zyphos/ZyphosFractalTerrain.cs","src/Aquarium.Zyphos/Worlds/zyphos-first-fractal-terrain.aquageo","tests/Aquarium.Engine.Fractal.Tests/FractalResourceBudgetPlannerTests.cs"],"source":"user demanded full fractal SDF rendering and noted Mimir sensor fusion shares the same temporal spatial evidence shape"}
{"timestamp":"2026-05-19T14:04:00+01:00","topic":"temporal-spatial-evidence-reservoir","lesson":"Temporal Gaussian accumulation now uses `TemporalSpatialEvidenceReservoir`, which owns stable-keyed spatial tracks, smoothing, delayed presentation, velocity prediction, confidence-weighted history, expiry, and max-track eviction. This pulls the common reservoir shape out from under Gaussian rendering so fractal SDF probes and Mimir sensor-fusion features can converge through the same evidence machinery before backend lowering.","files":["src/Aquarium.Engine.Fractal/Temporal/TemporalSpatialEvidenceObservation.cs","src/Aquarium.Engine.Fractal/Temporal/TemporalSpatialEvidenceReservoir.cs","src/Aquarium.Engine.Fractal/Temporal/TemporalGaussianAccumulator.cs","tests/Aquarium.Engine.Fractal.Tests/TemporalSpatialEvidenceReservoirTests.cs","docs/temporal-sdf-gaussian-field.md"],"source":"user pointed out fractal rendering and Mimir sensor fusion both accumulate surface/volume confidence into temporal reservoirs"}

View file

@ -111,6 +111,7 @@ renderer_state:
- Global GraphicsSettings document feeding render debug, exposure, bloom intensity, and bloom veil.
- Temporal resolve uses scene color, metadata, and control history only; dormant event history lanes are cut until a real producer and consumer contract exists.
- Aquarium owns the temporal SDF Gaussian field renderer boundary: clients can publish `AquariumTemporalGaussianField`, `TemporalGaussianAccumulator` can buffer stable keyed observations in world space, and D3D12 lowers those packets into an instanced compact-kernel splat pass that writes normal scene color/travel/metadata/control targets.
- Temporal Gaussian accumulation now lowers through `TemporalSpatialEvidenceReservoir`, a renderer-agnostic stable-key reservoir for confidence-weighted spatial samples with presentation delay, smoothing, velocity prediction, expiry, and max-track eviction. Gaussian splats are one lowering; fractal SDF probe evidence and Mimir sensor-fusion features should use the same reservoir shape when they need delayed coherence solving.
- Isolated Epiphany agent preview renders run through the real D3D12 renderer from src/Aquarium.Epiphany.AgentPreview; preview isolation is owned by a preview-only scene shader, while the engine exposes only final-frame PNG capture.
- Zyphos is the first nontrivial non-Epiphany client: a planetary-scale demo with spherical-domain terrain, atmospheric rim lighting, night-side glints, fixed-sky Umbros, and first-pass eclipse cadence.
- Zyphos/Umbros render-scale binary constants live in src/Aquarium.Zyphos/ZyphosUmbrosSystem.cs: Umbros is modeled as a 0.9-radius mutually tidally locked twin at 8 Zyphos radii, while the dim primary star phase moves through the Zyphos-local frame.

View file

@ -80,6 +80,7 @@
"IFS LOD should choose a stable hierarchy cut from cached node summaries, not blindly score every leaf. Each node needs bounds, max form/material error, coverage/normal or gradient bounds, estimated cost, online estimator state, residency, and summary/child payload handles. Children fade in when projected contribution exceeds threshold and resident budget allows; parent summaries remain renderable fallbacks.",
"The IFS contribution cache must probabilistically refresh node weights under a per-frame update budget. Use online mean/variance/confidence/sample-age state with nonzero exploration for visible or near-threshold nodes so weights converge instead of freezing stale guesses. Learned scoring may later rank update and residency priority from observed high-quality probes, but conservative summaries remain the safety authority for SDF bounds and visibility.",
"Aquarium's fractal renderer and Mimir-style sensor fusion share a deeper shape: both accumulate confidence-weighted spatial evidence into temporal reservoirs, then render a resolved surface/volume field. Keep the budget planner vocabulary general enough for CPU update work, GPU packet cost, RAM residency, and SSD request pressure; do not trap the future shared machinery inside renderer-only folklore.",
"Temporal Gaussian splats lower through TemporalSpatialEvidenceReservoir: stable keyed observations become delayed, smoothed, confidence-weighted tracks with velocity prediction, expiry, and max-track eviction before backend packet lowering. Treat Gaussian fields, fractal SDF probes, and Mimir sensor-fusion features as different evidence producers for this reservoir shape, not separate accumulator folklore.",
"Zyphos fractal stress data should keep authored topology richer than the first renderer backend: both Zyphos and Umbros expose lat/long, surface, object-scale, and cube-tile domains in `.aquageo`, with explicit continent/forest/tree/leaf/coast/pebble and crater/boulder/pebble recursion. The current D3D12 height-field stress table uploads 64 shaped 2D brushes and the SDF planet shaders carry separate cheap bounded quadtree-style relief.",
"The `.aquageo` compiler must preserve each tile declaration as its own ownership-tree node. Collapsing every claim under the final tile makes the authored multi-domain world a lie even if the brush count looks impressive.",
"Zyphos passes cube-tile domain metadata through height brush packets and binds those packets into the SDF pass. The planet shader may use authored brush packets for post-hit material/detail evaluation; traced geometry must wait for selected-cut/resident packet policy so SDF distance loops do not evaluate every brush at every step.",

View file

@ -40,7 +40,7 @@ public sealed class FractalResourceBudgetPlannerTests
store,
frameIndex: 10);
Assert.Equal(1, plan.UpdateNodes.Length);
Assert.Single(plan.UpdateNodes);
Assert.True(plan.GpuEstimatedCost <= budget.MaxGpuEstimatedCost);
Assert.True(plan.Residency.ResidentNodes.Count <= budget.MaxResidentPayloads);
Assert.True(plan.Residency.RequestedNodes.Count <= budget.MaxSsdRequests);

View file

@ -0,0 +1,98 @@
using System.Numerics;
using Aquarium.Engine.Fractal.Temporal;
namespace Aquarium.Engine.Fractal.Tests;
public sealed class TemporalSpatialEvidenceReservoirTests
{
[Fact]
public void ReservoirPredictsDelayedMotionForStableSpatialEvidence()
{
var reservoir = new TemporalSpatialEvidenceReservoir(
accumulationWindowSeconds: 2.0f,
presentationDelaySeconds: 0.5f,
smoothing: 1.0f);
reservoir.Observe([
Observation("feature/a", Vector3.Zero, time: 0.0f),
Observation("feature/a", new Vector3(1.0f, 0.0f, 0.0f), time: 1.0f),
]);
var sample = Assert.Single(reservoir.BuildSnapshot(renderTimeSeconds: 1.5f).Samples);
Assert.Equal(new Vector3(1.0f, 0.0f, 0.0f), sample.Center);
Assert.Equal(new Vector3(1.0f, 0.0f, 0.0f), sample.Velocity);
Assert.InRange(sample.HistoryWeight, 0.99f, 1.0f);
}
[Fact]
public void ReservoirExpiresSamplesOutsideWindow()
{
var reservoir = new TemporalSpatialEvidenceReservoir(
accumulationWindowSeconds: 1.0f,
presentationDelaySeconds: 0.0f);
reservoir.Observe([Observation("feature/old", Vector3.Zero, time: 0.0f)]);
var snapshot = reservoir.BuildSnapshot(renderTimeSeconds: 2.0f);
Assert.Empty(snapshot.Samples);
}
[Fact]
public void ReservoirEvictsLowestConfidenceTracksWhenOverBudget()
{
var reservoir = new TemporalSpatialEvidenceReservoir(
accumulationWindowSeconds: 5.0f,
presentationDelaySeconds: 0.0f,
smoothing: 1.0f,
maxTrackCount: 2);
reservoir.Observe([
Observation("weak", Vector3.Zero, time: 0.0f, confidence: 0.2f),
Observation("strong", Vector3.One, time: 0.0f, confidence: 1.0f),
Observation("middle", new Vector3(2.0f), time: 0.0f, confidence: 0.6f),
]);
var keys = reservoir.BuildSnapshot(renderTimeSeconds: 0.0f).Samples.Select(sample => sample.StableKey).ToArray();
Assert.DoesNotContain("weak", keys);
Assert.Contains("strong", keys);
Assert.Contains("middle", keys);
}
[Fact]
public void ReservoirPreservesRendererSpecificPayloadsWithoutOwningThem()
{
var reservoir = new TemporalSpatialEvidenceReservoir(
accumulationWindowSeconds: 5.0f,
presentationDelaySeconds: 0.0f);
var payload0 = new Vector4(0.2f, 0.4f, 0.6f, 0.8f);
var payload1 = new Vector4(4.0f, 1.5f, 0.0f, 0.0f);
reservoir.Observe([Observation("feature/payload", Vector3.Zero, time: 0.0f, payload0: payload0, payload1: payload1)]);
var sample = Assert.Single(reservoir.BuildSnapshot(renderTimeSeconds: 0.0f).Samples);
Assert.Equal(payload0, sample.Payload0);
Assert.Equal(payload1, sample.Payload1);
}
private static TemporalSpatialEvidenceObservation Observation(
string key,
Vector3 center,
float time,
float confidence = 1.0f,
Vector4? payload0 = null,
Vector4? payload1 = null)
{
return new TemporalSpatialEvidenceObservation(
key,
center,
new Vector3(0.1f),
Quaternion.Identity,
payload0 ?? Vector4.One,
payload1 ?? Vector4.Zero,
confidence,
time,
FieldId: 3);
}
}