@plasius/gpu-renderer 0.2.49 → 0.2.51

package/CHANGELOG.md

@@ -11,6 +11,38 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+- **Added**
+  - (placeholder)
+
+- **Changed**
+  - (placeholder)
+
+- **Fixed**
+  - (placeholder)
+
+- **Security**
+  - (placeholder)
+
+## [0.2.51] - 2026-10-18
+
+- Reuse immutable mesh, material, acceleration and lighting resources for camera-only wavefront updates, avoiding repeated CPU scene preparation during inspection.
+
+- **Added**
+  - (placeholder)
+
+- **Changed**
+  - (placeholder)
+
+- **Fixed**
+  - (placeholder)
+
+- **Security**
+  - (placeholder)
+
+## [0.2.50] - 2026-10-18
+
+- Fix fixed-wavefront dielectric queue overflow and concurrent per-path writes by selecting one probability-weighted continuation; preserve total internal reflection energy and avoid spurious metal refraction siblings.
+
 - **Added**
   - (placeholder)
 
@@ -1219,3 +1251,5 @@ All notable changes to this project will be documented in this file.
 [0.2.47]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.47
 [0.2.48]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.48
 [0.2.49]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.49
+[0.2.50]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.50
+[0.2.51]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.51

package/README.md

@@ -231,9 +231,13 @@ console.log(plan.wavefront.queueLayout.strategy);
 Wavefront materials support authored `KHR_materials_*` factors and extension
 textures, bounded nested media, Beer-Lambert attenuation, and reference
 transport helpers for reflected/transmitted branching and spectral dispersion.
-GPU rays carry up to four nested media and enqueue at most two dielectric
-continuations per hit; deeper nesting and full spectral rendering remain
-bounded by those explicit limits.
+GPU rays carry up to four medium identifiers and enqueue one selected
+continuation per hit. Dielectric lobes are weighted by their selection
+probability; total internal reflection retains unit throughput. The standalone
+CPU reference helper can describe both branches, but the fixed GPU path never
+enqueues an untracked sibling into its tile-sized queue. Physically qualified
+nested media, rough dielectric transport and full spectral rendering remain
+separate work. See [the Amber correction](docs/amber-transport-correction.md).
 
 ```js
 import {
@@ -987,3 +991,8 @@ Production demo helpers and their regression tests now live in `@plasius/gpu-sha
 Create the wavefront renderer with `progressive: true` to retain linear radiance across frames. `samplesPerPixel` at creation is the maximum batch capacity; pass a smaller value to `renderOnce({ samplesPerPixel })` or `renderFrame({ samplesPerPixel })`. Submit batches serially. `renderFrame()` awaits completion by default; with `renderOnce()`, await `renderer.device.queue.onSubmittedWorkDone()` before reporting completed samples. `getSnapshot().accumulatedSamplesPerPixel` reports submitted history samples.
 
 Camera or scene updates reset history automatically; `resetAccumulation()` also discards it without reallocating. Do not call `updateCamera()` between refinement passes unless the view changed. Progressive mode uses independent frame seeds, overriding static-frame stable sample routing. Denoising is applied after accumulation. Leave `progressive` unset for the existing independent-frame path. See [ADR 0038](docs/adrs/adr-0038-progressive-linear-radiance.md) for memory costs and host rollout responsibilities.
+
+Camera-only wavefront updates preserve the loaded mesh, material, acceleration
+and lighting resources while resetting progressive accumulation. Changing the
+view no longer rebuilds those CPU scene tables; scene updates retain their
+existing reconstruction path.

package/dist/index.cjs

@@ -6042,7 +6042,7 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord) -> ScatterResult {
     if (cannotRefract || transmissionSelector < transmissionReflectChance) {
       return ScatterResult(
         vec4<f32>(reflect(ray.direction.xyz, normal), 0.0),
-        1.0,
+        select(transmissionReflectChance, 1.0, cannotRefract),
         ray.mediumRefId,
         RAY_FLAG_DELTA_SAMPLE,
         SCATTER_LOBE_DELTA_REFLECTION,
@@ -6050,7 +6050,7 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord) -> ScatterResult {
     }
     return ScatterResult(
       vec4<f32>(refract_direction(ray.direction.xyz, normal, etaRatio), 0.0),
-      1.0,
+      1.0 - transmissionReflectChance,
       transmitted_medium_ref_id(ray, hit),
       RAY_FLAG_DELTA_SAMPLE,
       SCATTER_LOBE_DELTA_TRANSMISSION,
@@ -6442,7 +6442,6 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
   }
   record_deferred_path_throughput(ray, continuationThroughput);
   let throughput = ray.throughput.xyz * continuationThroughput;
-  let transmissionBranch = scatter.lobeKind == SCATTER_LOBE_DELTA_TRANSMISSION;
   let nextMediumStack = select(
     transitioned_medium_stack(ray, hit),
     ray.mediumStack,
@@ -6481,66 +6480,9 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     nextMediumStack
   );
 
-  // Keep both sides of a dielectric event when queue capacity permits. The
-  // selected continuation remains the primary sample; this bounded second
-  // record preserves a reflected/transmitted branch for explicit transport.
-  if (
-    scatter.lobeKind == SCATTER_LOBE_DELTA_REFLECTION ||
-    scatter.lobeKind == SCATTER_LOBE_DELTA_TRANSMISSION
-  ) {
-    let secondaryIndex = atomicAdd(&counters.nextCount, 1u);
-    if (secondaryIndex < config.tilePixelCount) {
-      let secondaryIsReflection = transmissionBranch;
-      let secondaryDirection = select(
-        refract_direction(ray.direction.xyz, surface_shading_normal(hit),
-          select(1.0 / max(hit.material.w, 1.01), max(hit.material.w, 1.01), hit.frontFace == 1u)),
-        reflect(ray.direction.xyz, surface_shading_normal(hit)),
-        secondaryIsReflection
-      );
-      let secondaryThroughput = select(
-        surface_delta_transmission_throughput(hit, continuationViewDirection),
-        surface_delta_reflection_throughput(hit, continuationViewDirection),
-        secondaryIsReflection
-      ) * segmentTransmittance;
-      let secondaryStack = select(
-        transitioned_medium_stack(ray, hit),
-        ray.mediumStack,
-        secondaryIsReflection
-      );
-      let secondaryDepth = select(
-        transitioned_medium_stack_depth(ray, hit),
-        ray.mediumStackDepth,
-        secondaryIsReflection
-      );
-      let secondaryMedium = select(
-        transmitted_medium_ref_id(ray, hit),
-        ray.mediumRefId,
-        secondaryIsReflection
-      );
-      nextQueue[secondaryIndex] = RayRecord(
-        ray.rayId,
-        ray.rayId,
-        ray.sourcePixelId,
-        ray.sampleId,
-        ray.bounce + 1u,
-        secondaryMedium,
-        scatter.flags,
-        secondaryDepth,
-        vec4<f32>(
-          offset_origin(
-            hit.position.xyz,
-            hit.geometricNormal.xyz,
-            hit.shadingNormal.xyz,
-            secondaryDirection
-          ),
-          1.0
-        ),
-        vec4<f32>(secondaryDirection, 0.0),
-        vec4<f32>(ray.throughput.xyz * secondaryThroughput, scatter.pdf),
-        secondaryStack
-      );
-    }
-  }
+  // One continuation per incoming path keeps the tile queue bounded and gives
+  // each accumulation/deferred record a single writer. The selected dielectric
+  // lobe is probability-weighted; a sibling must never be silently dropped.
 }
 
 @compute @workgroup_size(1)
@@ -7843,10 +7785,20 @@ fn surface_continuation_throughput(
   scatter: ScatterResult
 ) -> vec3<f32> {
   if ((scatter.flags & RAY_FLAG_DELTA_SAMPLE) != 0u) {
+    let refractive = hit.materialKind == 2u || hit.materialKind == 3u || hit.materialExtension.z > 0.001;
+    if (refractive) {
+      let normal = surface_shading_normal(hit);
+      let eta = select(max(hit.material.w, 1.01), 1.0 / max(hit.material.w, 1.01), hit.frontFace == 1u);
+      let cosine = min(dot(viewDirection, normal), 1.0);
+      let cannotRefract = eta * sqrt(max(0.0, 1.0 - cosine * cosine)) > 1.0;
+      if (cannotRefract) {
+        return vec3<f32>(1.0);
+      }
+    }
     if (scatter.lobeKind == SCATTER_LOBE_DELTA_TRANSMISSION) {
-      return surface_delta_transmission_throughput(hit, viewDirection);
+      return surface_delta_transmission_throughput(hit, viewDirection) / scatter.pdf;
     }
-    return surface_delta_reflection_throughput(hit, viewDirection);
+    return surface_delta_reflection_throughput(hit, viewDirection) / scatter.pdf;
   }
   if (scatter.pdf <= 0.000001) {
     return vec3<f32>(0.0);
@@ -10694,6 +10646,12 @@ function resolveCamera(input, width, height) {
     tanHalfFovY
   });
 }
+function updateWavefrontCameraConfig(config, camera) {
+  return Object.freeze({
+    ...config,
+    camera: resolveCamera(camera, config.width, config.height)
+  });
+}
 function estimateWavefrontPathTracingMemory(options = {}) {
   const width = readPositiveInteger2("width", options.width, DEFAULT_WIDTH);
   const height = readPositiveInteger2("height", options.height, DEFAULT_HEIGHT);
@@ -13614,7 +13572,7 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
   function updateCamera(cameraOptions = {}) {
     progressive?.reset();
     activeCameraOptions = cameraOptions;
-    config = rebuildLiveConfig();
+    config = updateWavefrontCameraConfig(config, cameraOptions);
     return config;
   }
   function getSnapshot() {