@plasius/gpu-renderer 0.2.49 → 0.2.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-renderer",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "description": "Framework-agnostic WebGPU renderer runtime for Plasius projects.",
   "type": "module",
   "sideEffects": false,

package/src/wavefront-compute.js

@@ -18,6 +18,7 @@ import {
 import {
   estimateWavefrontPathTracingMemoryForConfig,
   createWavefrontPathTracingComputeConfig,
+  updateWavefrontCameraConfig,
   packEnvironmentPortals,
   supportsWavefrontPathTracingCompute,
 } from "./wavefront-config.js";
@@ -1040,7 +1041,7 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
   function updateCamera(cameraOptions = {}) {
     progressive?.reset();
     activeCameraOptions = cameraOptions;
-    config = rebuildLiveConfig();
+    config = updateWavefrontCameraConfig(config, cameraOptions);
     return config;
   }
 

package/src/wavefront-config.js

@@ -265,6 +265,14 @@ function resolveCamera(input, width, height) {
   });
 }
 
+/** Camera changes do not invalidate immutable mesh, material or lighting resources. */
+export function updateWavefrontCameraConfig(config, camera) {
+  return Object.freeze({
+    ...config,
+    camera: resolveCamera(camera, config.width, config.height),
+  });
+}
+
 export function estimateWavefrontPathTracingMemory(options = {}) {
   const width = readPositiveInteger("width", options.width, DEFAULT_WIDTH);
   const height = readPositiveInteger("height", options.height, DEFAULT_HEIGHT);

package/src/wavefront-shader-kernels.js

@@ -451,7 +451,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,
@@ -459,7 +459,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,
@@ -851,7 +851,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,
@@ -890,66 +889,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)

package/src/wavefront-shader-lighting.js

@@ -633,10 +633,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);