@plasius/gpu-renderer 0.2.6 → 0.2.8

package/src/wavefront-compute.js

@@ -13,17 +13,19 @@ const DEFAULT_MAX_DEPTH = 6;
 const DEFAULT_TILE_SIZE = 128;
 const DEFAULT_SAMPLES_PER_PIXEL = 1;
 const MAX_SAMPLES_PER_PIXEL = 256;
-const DEFAULT_BRDF_LUT_SIZE = 256;
+const DEFAULT_BRDF_LUT_SIZE = 128;
+const DEFAULT_BRDF_LUT_SAMPLE_COUNT = 256;
 const DEFAULT_MAX_FRAME_PASSES_PER_SUBMISSION = 256;
 const DEFAULT_SCENE_OBJECT_CAPACITY = 128;
 const DEFAULT_ENVIRONMENT_PORTAL_CAPACITY = 32;
+const DEFAULT_MEDIUM_PHASE_MODEL = 0;
 const WORKGROUP_SIZE = 64;
 export const rendererWavefrontComputeMode = "webgpu-compute";
 export const rendererWavefrontComputeWorkgroupSize = WORKGROUP_SIZE;
 export const rendererWavefrontComputeStatsStride = 8;
 const RAY_RECORD_BYTES = 80;
 const HIT_RECORD_BYTES = 256;
-const SCENE_OBJECT_RECORD_BYTES = 144;
+const SCENE_OBJECT_RECORD_BYTES = 160;
 const MESH_VERTEX_RECORD_BYTES = 48;
 const MESH_RANGE_RECORD_BYTES = 240;
 const TRIANGLE_RECORD_BYTES = 352;
@@ -32,11 +34,13 @@ const BVH_NODE_RECORD_BYTES = 48;
 const BVH_LEAF_REF_RECORD_BYTES = 16;
 const EMISSIVE_TRIANGLE_INDEX_BYTES = 4;
 const ENVIRONMENT_PORTAL_RECORD_BYTES = 96;
+const MEDIUM_TABLE_ROWS = 2;
 const ACCUMULATION_RECORD_BYTES = 16;
 const PATH_VERTEX_RECORD_BYTES = 16;
 const GPU_SUBMITTED_WORK_TIMEOUT_MS = 5_000;
 const GPU_READBACK_COMPLETION_TIMEOUT_MS = 60_000;
 const GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS = 60_000;
+const GPU_MAX_SUBMITTED_WORK_DEADLINE_MS = 180_000;
 const CONFIG_BUFFER_BYTES = 320;
 const COUNTER_DISPATCH_ARGS_OFFSET = 16;
 const INDIRECT_DISPATCH_ARGS_BYTES = 12;
@@ -437,6 +441,183 @@ function deriveBounds(input) {
   return null;
 }
 
+function deriveBeerLambertAbsorptionFromAttenuationColor(
+  attenuationColor,
+  attenuationDistance,
+  density = 1
+) {
+  const distance = Number(attenuationDistance);
+  const densityScale = Math.max(0, Number(density) || 0);
+  if (!Number.isFinite(distance) || distance <= 0 || densityScale <= 0) {
+    return [0, 0, 0];
+  }
+  return attenuationColor.slice(0, 3).map((channel) => {
+    const clamped = clamp(Number(channel) || 0, 0.0001, 1);
+    return Math.max(0, (-Math.log(clamped) / distance) * densityScale);
+  });
+}
+
+function readMediumPhaseModel(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(0, Math.trunc(value));
+  }
+  switch (String(value ?? "").trim().toLowerCase()) {
+    case "isotropic":
+    default:
+      return DEFAULT_MEDIUM_PHASE_MODEL;
+  }
+}
+
+function resolveWavefrontVolumeInput(input) {
+  return input?.volume ?? input?.material?.volume ?? null;
+}
+
+function normalizeWavefrontThickness(input, label) {
+  const volume = resolveWavefrontVolumeInput(input);
+  return Math.max(
+    0,
+    readFiniteNumber(
+      label,
+      input?.thickness ?? volume?.thickness ?? input?.material?.thickness,
+      0
+    )
+  );
+}
+
+function resolveWavefrontMediumId(input, fallbackId = 1) {
+  return (
+    input?.mediumRefId ??
+    input?.mediumId ??
+    input?.material?.mediumId ??
+    input?.materialRefId ??
+    input?.material?.id ??
+    input?.materialId ??
+    input?.id ??
+    fallbackId
+  );
+}
+
+function deriveWavefrontTransportMedium(input, fallbackId = 1) {
+  const resolvedId = resolveWavefrontMediumId(input, fallbackId);
+  if (input?.medium) {
+    return normalizeWavefrontMedium(
+      {
+        ...input.medium,
+        id: input.medium.id ?? input.medium.mediumId ?? resolvedId,
+      },
+      fallbackId
+    );
+  }
+  const volume = resolveWavefrontVolumeInput(input);
+  if (!volume) {
+    return null;
+  }
+  return normalizeWavefrontMedium(
+    {
+      id: resolvedId,
+      phaseModel: volume.phaseModel,
+      density: volume.density,
+      attenuationColor: volume.attenuationColor,
+      attenuationDistance: volume.attenuationDistance,
+      absorption: volume.absorption,
+      scattering: volume.scattering,
+    },
+    fallbackId
+  );
+}
+
+function normalizeWavefrontMedium(input = {}, index = 0) {
+  const id = readNonNegativeInteger("medium id", input.id ?? input.mediumId, index);
+  const density = Math.max(0, readFiniteNumber("medium density", input.density, 1));
+  const attenuationColor = asColor(
+    input.attenuationColor ?? input.color ?? input.medium?.attenuationColor,
+    [1, 1, 1, 1]
+  );
+  const attenuationDistance = readFiniteNumber(
+    "medium attenuationDistance",
+    input.attenuationDistance ?? input.distance ?? input.medium?.attenuationDistance,
+    0
+  );
+  const absorption =
+    Array.isArray(input.absorption) || Array.isArray(input.medium?.absorption)
+      ? asVec3(input.absorption ?? input.medium?.absorption, [0, 0, 0]).map((value) =>
+          Math.max(0, Number(value) || 0)
+        )
+      : deriveBeerLambertAbsorptionFromAttenuationColor(
+          attenuationColor,
+          attenuationDistance,
+          density
+        );
+  const scattering = asVec3(
+    input.scattering ?? input.medium?.scattering,
+    [0, 0, 0]
+  ).map((value) => Math.max(0, Number(value) || 0));
+  return Object.freeze({
+    id,
+    phaseModel: readMediumPhaseModel(input.phaseModel ?? input.medium?.phaseModel),
+    density,
+    attenuationColor: Object.freeze(attenuationColor),
+    attenuationDistance,
+    absorption: Object.freeze(absorption),
+    scattering: Object.freeze(scattering),
+  });
+}
+
+function collectWavefrontMediums(options, meshes, sceneObjects = []) {
+  const mediumsById = new Map();
+  mediumsById.set(
+    0,
+    Object.freeze({
+      id: 0,
+      phaseModel: DEFAULT_MEDIUM_PHASE_MODEL,
+      density: 0,
+      attenuationColor: Object.freeze([1, 1, 1, 1]),
+      attenuationDistance: 0,
+      absorption: Object.freeze([0, 0, 0]),
+      scattering: Object.freeze([0, 0, 0]),
+    })
+  );
+
+  const register = (input, fallbackId = mediumsById.size) => {
+    if (!input) {
+      return;
+    }
+    const normalized = normalizeWavefrontMedium(
+      typeof input === "object" ? { id: fallbackId, ...input } : { id: fallbackId },
+      fallbackId
+    );
+    const existing = mediumsById.get(normalized.id);
+    if (existing && JSON.stringify(existing) !== JSON.stringify(normalized)) {
+      throw new Error(`Medium id ${normalized.id} is defined more than once with different values.`);
+    }
+    mediumsById.set(normalized.id, normalized);
+  };
+
+  for (const medium of options.mediums ?? []) {
+    register(medium);
+  }
+  for (const mesh of meshes) {
+    register(mesh.medium, mesh.mediumRefId ?? mesh.medium?.id ?? 0);
+  }
+  for (const mesh of meshes) {
+    if ((mesh.mediumRefId ?? 0) > 0 && !mediumsById.has(mesh.mediumRefId)) {
+      register({ id: mesh.mediumRefId });
+    }
+  }
+  for (const object of sceneObjects) {
+    register(object.medium, object.mediumRefId ?? object.medium?.id ?? 0);
+  }
+  for (const object of sceneObjects) {
+    if ((object.mediumRefId ?? 0) > 0 && !mediumsById.has(object.mediumRefId)) {
+      register({ id: object.mediumRefId });
+    }
+  }
+
+  return Object.freeze(
+    Array.from(mediumsById.values()).sort((left, right) => left.id - right.id)
+  );
+}
+
 export function normalizeWavefrontSceneObject(input = {}, index = 0) {
   const bounds = deriveBounds(input);
   const kind = readObjectKind(input.kind ?? input.type ?? (bounds ? "box" : "sphere"));
@@ -474,6 +655,7 @@ export function normalizeWavefrontSceneObject(input = {}, index = 0) {
     input.specularColor ?? input.material?.specularColor,
     [1, 1, 1, 1]
   ).map((value, componentIndex) => (componentIndex < 3 ? clamp(value, 0, 1) : 1));
+  const medium = deriveWavefrontTransportMedium(input, index + 1);
   const resolvedMaterialKind =
     emission[0] > 0 || emission[1] > 0 || emission[2] > 0
       ? MATERIAL_EMISSIVE
@@ -488,6 +670,12 @@ export function normalizeWavefrontSceneObject(input = {}, index = 0) {
     kind,
     materialKind: resolvedMaterialKind,
     flags: readNonNegativeInteger("flags", input.flags, 0),
+    mediumRefId: readNonNegativeInteger(
+      "mediumRefId",
+      input.mediumRefId ?? medium?.id ?? input.medium?.id ?? input.mediumId,
+      0
+    ),
+    medium,
     center: Object.freeze(center),
     halfExtent: Object.freeze(halfExtent),
     color: Object.freeze(color),
@@ -511,6 +699,7 @@ export function normalizeWavefrontSceneObject(input = {}, index = 0) {
     ),
     specular: clamp(readFiniteNumber("specular", input.specular ?? input.material?.specular, 1), 0, 1),
     specularColor: Object.freeze(specularColor),
+    thickness: normalizeWavefrontThickness(input, "thickness"),
     transmission,
   });
 }
@@ -620,6 +809,7 @@ export function normalizeWavefrontMesh(input = {}, meshIndex = 0) {
     input.specularColor ?? input.material?.specularColor,
     [1, 1, 1, 1]
   ).map((value, componentIndex) => (componentIndex < 3 ? clamp(value, 0, 1) : 1));
+  const medium = deriveWavefrontTransportMedium(input, meshIndex + 1);
   const resolvedMaterialKind =
     emission[0] > 0 || emission[1] > 0 || emission[2] > 0
       ? MATERIAL_EMISSIVE
@@ -644,9 +834,14 @@ export function normalizeWavefrontMesh(input = {}, meshIndex = 0) {
     ),
     mediumRefId: readNonNegativeInteger(
       "mesh mediumRefId",
-      input.mediumRefId ?? input.medium?.id ?? input.mediumId,
+      input.mediumRefId ??
+        medium?.id ??
+        input.medium?.id ??
+        input.mediumId ??
+        input.material?.mediumId,
       0
     ),
+    medium,
     color: Object.freeze(color),
     emission: Object.freeze(emission),
     roughness: clamp(readFiniteNumber("roughness", input.roughness ?? input.material?.roughness, 0.72), 0, 1),
@@ -668,6 +863,7 @@ export function normalizeWavefrontMesh(input = {}, meshIndex = 0) {
     ),
     specular: clamp(readFiniteNumber("specular", input.specular ?? input.material?.specular, 1), 0, 1),
     specularColor: Object.freeze(specularColor),
+    thickness: normalizeWavefrontThickness(input, "mesh thickness"),
     transmission,
     baseColorTexture: input.baseColorTexture ?? input.material?.baseColorTexture ?? null,
     metallicRoughnessTexture:
@@ -738,104 +934,9 @@ function normalizeVectorOrFallback(vector, fallback) {
   return normalize(Array.isArray(vector) ? vector : fallback, fallback);
 }
 
-function buildTriangleTangentBasis(v0, v1, v2, uv0, uv1, uv2, fallbackNormal) {
-  const edge1 = subtract(v1, v0);
-  const edge2 = subtract(v2, v0);
-  const deltaUv1 = [uv1[0] - uv0[0], uv1[1] - uv0[1]];
-  const deltaUv2 = [uv2[0] - uv0[0], uv2[1] - uv0[1]];
-  const determinant = deltaUv1[0] * deltaUv2[1] - deltaUv1[1] * deltaUv2[0];
-  if (Math.abs(determinant) < 1e-6) {
-    const tangentFallback = Math.abs(fallbackNormal[1]) < 0.999 ? [0, 1, 0] : [1, 0, 0];
-    const tangent = normalize(cross(tangentFallback, fallbackNormal), [1, 0, 0]);
-    const bitangent = normalize(cross(fallbackNormal, tangent), [0, 0, 1]);
-    return { tangent, bitangent };
-  }
-  const inverse = 1 / determinant;
-  const tangent = normalize(
-    [
-      inverse * (edge1[0] * deltaUv2[1] - edge2[0] * deltaUv1[1]),
-      inverse * (edge1[1] * deltaUv2[1] - edge2[1] * deltaUv1[1]),
-      inverse * (edge1[2] * deltaUv2[1] - edge2[2] * deltaUv1[1]),
-    ],
-    [1, 0, 0]
-  );
-  const bitangent = normalize(
-    [
-      inverse * (-edge1[0] * deltaUv2[0] + edge2[0] * deltaUv1[0]),
-      inverse * (-edge1[1] * deltaUv2[0] + edge2[1] * deltaUv1[0]),
-      inverse * (-edge1[2] * deltaUv2[0] + edge2[2] * deltaUv1[0]),
-    ],
-    [0, 0, 1]
-  );
-  return { tangent, bitangent };
-}
-
-function applyNormalMap(normal, tangent, bitangent, normalTexture, uv) {
-  if (!normalTexture) {
-    return normalizeVectorOrFallback(normal, [0, 1, 0]);
-  }
-  const sample = sampleTextureRgba(normalTexture, uv, "linear");
-  const strength = clampUnit(normalTexture.scale ?? 1);
-  const tangentNormal = normalize(
-    [
-      (sample[0] * 2 - 1) * strength,
-      (sample[1] * 2 - 1) * strength,
-      1 + (sample[2] * 2 - 1 - 1) * strength,
-    ],
-    [0, 0, 1]
-  );
-  return normalize(
-    [
-      tangent[0] * tangentNormal[0] + bitangent[0] * tangentNormal[1] + normal[0] * tangentNormal[2],
-      tangent[1] * tangentNormal[0] + bitangent[1] * tangentNormal[1] + normal[1] * tangentNormal[2],
-      tangent[2] * tangentNormal[0] + bitangent[2] * tangentNormal[1] + normal[2] * tangentNormal[2],
-    ],
-    normal
-  );
-}
-
-function sampleBaseColor(mesh, uv) {
-  const sample = mesh.baseColorTexture ? sampleTextureRgba(mesh.baseColorTexture, uv, "srgb") : [1, 1, 1, 1];
-  return [
-    clampUnit(mesh.color[0] * sample[0]),
-    clampUnit(mesh.color[1] * sample[1]),
-    clampUnit(mesh.color[2] * sample[2]),
-    clampUnit((mesh.color[3] ?? 1) * sample[3]),
-  ];
-}
-
-function sampleSurfaceMaterial(mesh, uv) {
-  const textureSample = mesh.metallicRoughnessTexture
-    ? sampleTextureRgba(mesh.metallicRoughnessTexture, uv, "linear")
-    : [1, 1, 1, 1];
-  return {
-    roughness: clamp(mesh.roughness * textureSample[1], 0, 1),
-    metallic: clamp(mesh.metallic * textureSample[2], 0, 1),
-  };
-}
-
-function averageColors(colors) {
-  const count = Math.max(colors.length, 1);
-  return colors.reduce(
-    (accumulator, color) => [
-      accumulator[0] + color[0] / count,
-      accumulator[1] + color[1] / count,
-      accumulator[2] + color[2] / count,
-      accumulator[3] + color[3] / count,
-    ],
-    [0, 0, 0, 0]
-  );
-}
-
-function averageNumbers(values, fallback = 0) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return fallback;
-  }
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-
-function createMeshTriangleRecords(meshes) {
+function createMeshTriangleRecords(meshes, gpuMaterialSource = null) {
   const source = Array.isArray(meshes) ? meshes : [];
+  const resolvedMaterialSource = gpuMaterialSource ?? createWavefrontGpuMaterialSource(source);
   let nextTriangleId = 0;
   return source.flatMap((meshInput, meshIndex) => {
     const mesh = normalizeWavefrontMesh(meshInput, meshIndex);
@@ -854,16 +955,6 @@ function createMeshTriangleRecords(meshes) {
       const uv0 = mesh.uvs ? readVector2(mesh.uvs, a) : [0, 0];
       const uv1 = mesh.uvs ? readVector2(mesh.uvs, b) : [0, 0];
       const uv2 = mesh.uvs ? readVector2(mesh.uvs, c) : [0, 0];
-      const tangentBasis = buildTriangleTangentBasis(v0, v1, v2, uv0, uv1, uv2, faceNormal);
-      const shadedN0 = applyNormalMap(n0, tangentBasis.tangent, tangentBasis.bitangent, mesh.normalTexture, uv0);
-      const shadedN1 = applyNormalMap(n1, tangentBasis.tangent, tangentBasis.bitangent, mesh.normalTexture, uv1);
-      const shadedN2 = applyNormalMap(n2, tangentBasis.tangent, tangentBasis.bitangent, mesh.normalTexture, uv2);
-      const sampledColors = [sampleBaseColor(mesh, uv0), sampleBaseColor(mesh, uv1), sampleBaseColor(mesh, uv2)];
-      const sampledMaterials = [
-        sampleSurfaceMaterial(mesh, uv0),
-        sampleSurfaceMaterial(mesh, uv1),
-        sampleSurfaceMaterial(mesh, uv2),
-      ];
       const bounds = triangleBounds(v0, v1, v2);
 
       triangles.push(
@@ -878,17 +969,17 @@ function createMeshTriangleRecords(meshes) {
           v0: Object.freeze(v0),
           v1: Object.freeze(v1),
           v2: Object.freeze(v2),
-          n0: Object.freeze(shadedN0),
-          n1: Object.freeze(shadedN1),
-          n2: Object.freeze(shadedN2),
+          n0: Object.freeze(n0),
+          n1: Object.freeze(n1),
+          n2: Object.freeze(n2),
           uv0: Object.freeze(uv0),
           uv1: Object.freeze(uv1),
           uv2: Object.freeze(uv2),
-          color: Object.freeze(averageColors(sampledColors)),
+          color: mesh.color,
           emission: mesh.emission,
           material: Object.freeze([
-            averageNumbers(sampledMaterials.map((sample) => sample.roughness), mesh.roughness),
-            averageNumbers(sampledMaterials.map((sample) => sample.metallic), mesh.metallic),
+            mesh.roughness,
+            mesh.metallic,
             mesh.opacity,
             mesh.ior,
           ]),
@@ -902,7 +993,7 @@ function createMeshTriangleRecords(meshes) {
             mesh.clearcoatRoughness,
             mesh.specular,
             mesh.transmission,
-            0,
+            mesh.thickness,
           ]),
           specularColor: Object.freeze([
             mesh.specularColor[0] ?? 1,
@@ -910,6 +1001,27 @@ function createMeshTriangleRecords(meshes) {
             mesh.specularColor[2] ?? 1,
             1,
           ]),
+          baseColorAtlas: Object.freeze(
+            resolvedMaterialSource.baseColorAtlas.resolveRect(mesh.baseColorTexture)
+          ),
+          metallicRoughnessAtlas: Object.freeze(
+            resolvedMaterialSource.metallicRoughnessAtlas.resolveRect(mesh.metallicRoughnessTexture)
+          ),
+          normalAtlas: Object.freeze(
+            resolvedMaterialSource.normalAtlas.resolveRect(mesh.normalTexture)
+          ),
+          occlusionAtlas: Object.freeze(
+            resolvedMaterialSource.occlusionAtlas.resolveRect(mesh.occlusionTexture)
+          ),
+          emissiveAtlas: Object.freeze(
+            resolvedMaterialSource.emissiveAtlas.resolveRect(mesh.emissiveTexture)
+          ),
+          textureSettings: Object.freeze([
+            clampUnit(mesh.normalTexture?.scale ?? mesh.normalTexture?.strength ?? 1),
+            clampUnit(mesh.occlusionTexture?.strength ?? 1),
+            clampUnit(mesh.emissiveTexture?.strength ?? 1),
+            0,
+          ]),
           bounds: Object.freeze({
             min: Object.freeze(bounds.min),
             max: Object.freeze(bounds.max),
@@ -992,9 +1104,10 @@ function buildBvh(triangles, maxLeafTriangles = 4) {
   });
 }
 
-export function createWavefrontMeshAcceleration(meshes = []) {
+export function createWavefrontMeshAcceleration(meshes = [], gpuMaterialSource = null) {
   const source = Array.isArray(meshes) ? meshes : [meshes];
-  const triangles = createMeshTriangleRecords(source);
+  const resolvedMaterialSource = gpuMaterialSource ?? createWavefrontGpuMaterialSource(source);
+  const triangles = createMeshTriangleRecords(source, resolvedMaterialSource);
   return buildBvh(triangles);
 }
 
@@ -1231,7 +1344,7 @@ export function createWavefrontGpuMaterialSource(meshes = []) {
       mesh.clearcoatRoughness,
       mesh.specular,
       mesh.transmission,
-      0,
+      mesh.thickness,
     ]);
     writeVec4(floatView, byteOffset + 80, [
       mesh.specularColor[0] ?? 1,
@@ -1329,12 +1442,13 @@ export function createWavefrontBvhBuildLevels(triangleCountInput) {
 }
 
 function resolveAccelerationBuildMode(options = {}) {
-  const mode = options.accelerationBuildMode ?? (options.displayQuality === true ? "gpu" : "cpu-debug");
-  if (mode !== "gpu" && mode !== "cpu-debug") {
-    throw new Error("accelerationBuildMode must be either \"gpu\" or \"cpu-debug\".");
-  }
-  if (options.displayQuality === true && mode !== "gpu") {
-    throw new Error("Display-quality path tracing requires GPU-built mesh acceleration.");
+  const requestedMode =
+    options.accelerationBuildMode ?? (options.displayQuality === true ? "cpu-upload" : "cpu-debug");
+  const mode = requestedMode === "cpu-debug" ? "cpu-upload" : requestedMode;
+  if (mode !== "gpu" && mode !== "cpu-upload") {
+    throw new Error(
+      "accelerationBuildMode must be either \"gpu\", \"cpu-upload\", or the legacy alias \"cpu-debug\"."
+    );
   }
   return mode;
 }
@@ -1419,7 +1533,7 @@ export function createWavefrontGpuMeshSource(meshes = [], gpuMaterialSourceInput
       mesh.clearcoatRoughness,
       mesh.specular,
       mesh.transmission,
-      0,
+      mesh.thickness,
     ]);
     writeVec4(meshFloats, floatOffset * 4 + 128, [
       mesh.specularColor[0] ?? 1,
@@ -1534,12 +1648,17 @@ function normalizeSceneObjects(sceneObjects, useDefaultScene = true) {
   return source.map((object, index) => normalizeWavefrontSceneObject(object, index));
 }
 
+function normalizeWavefrontMeshes(meshes) {
+  const source = Array.isArray(meshes) ? meshes : [];
+  return source.map((mesh, index) => normalizeWavefrontMesh(mesh, index));
+}
+
 function normalizeMeshes(options = {}) {
   if (Array.isArray(options.meshes)) {
-    return options.meshes;
+    return normalizeWavefrontMeshes(options.meshes);
   }
   if (options.mesh) {
-    return [options.mesh];
+    return normalizeWavefrontMeshes([options.mesh]);
   }
   return [];
 }
@@ -1881,8 +2000,8 @@ export function createWavefrontPathTracingComputeConfig(options = {}) {
       ? createWavefrontGpuMeshSource(meshes, gpuMaterialSource)
       : createWavefrontGpuMeshSource([]);
   const meshAcceleration =
-    accelerationBuildMode === "cpu-debug"
-      ? createWavefrontMeshAcceleration(meshes)
+    accelerationBuildMode === "cpu-upload"
+      ? createWavefrontMeshAcceleration(meshes, gpuMaterialSource)
       : Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
   const emissiveTriangleIndices = createWavefrontEmissiveTriangleIndexSource(
     meshes,
@@ -1899,6 +2018,7 @@ export function createWavefrontPathTracingComputeConfig(options = {}) {
   const sceneObjects = Object.freeze(
     normalizeSceneObjects(options.sceneObjects, meshes.length === 0)
   );
+  const mediums = collectWavefrontMediums(options, meshes, sceneObjects);
   const sceneObjectCapacity = Math.max(
     sceneObjects.length,
     readPositiveInteger("sceneObjectCapacity", options.sceneObjectCapacity, DEFAULT_SCENE_OBJECT_CAPACITY)
@@ -1971,6 +2091,8 @@ export function createWavefrontPathTracingComputeConfig(options = {}) {
     sceneObjects,
     sceneObjectCount: sceneObjects.length,
     sceneObjectCapacity,
+    mediums,
+    mediumCount: mediums.length,
     accelerationBuildMode,
     gpuAccelerationBuildRequired: accelerationBuildMode === "gpu" && triangleCount > 0,
     gpuMeshSource,
@@ -2089,29 +2211,30 @@ export function packWavefrontSceneObjects(sceneObjects, capacity = sceneObjects.
     uintView[u32 + 1] = object.id;
     uintView[u32 + 2] = object.materialKind;
     uintView[u32 + 3] = object.flags;
-    writeVec4(floatView, byteOffset + 16, [...object.center, 0]);
-    writeVec4(floatView, byteOffset + 32, [...object.halfExtent, 0]);
-    writeVec4(floatView, byteOffset + 48, object.color);
-    writeVec4(floatView, byteOffset + 64, object.emission);
-    writeVec4(floatView, byteOffset + 80, [
+    uintView[u32 + 4] = object.mediumRefId;
+    writeVec4(floatView, byteOffset + 32, [...object.center, 0]);
+    writeVec4(floatView, byteOffset + 48, [...object.halfExtent, 0]);
+    writeVec4(floatView, byteOffset + 64, object.color);
+    writeVec4(floatView, byteOffset + 80, object.emission);
+    writeVec4(floatView, byteOffset + 96, [
       object.roughness,
       object.metallic,
       object.opacity,
       object.ior,
     ]);
-    writeVec4(floatView, byteOffset + 96, [
+    writeVec4(floatView, byteOffset + 112, [
       object.sheenColor[0] ?? 0,
       object.sheenColor[1] ?? 0,
       object.sheenColor[2] ?? 0,
       object.clearcoat,
     ]);
-    writeVec4(floatView, byteOffset + 112, [
+    writeVec4(floatView, byteOffset + 128, [
       object.clearcoatRoughness,
       object.specular,
       object.transmission,
-      0,
+      object.thickness,
     ]);
-    writeVec4(floatView, byteOffset + 128, [
+    writeVec4(floatView, byteOffset + 144, [
       object.specularColor[0] ?? 1,
       object.specularColor[1] ?? 1,
       object.specularColor[2] ?? 1,
@@ -2710,7 +2833,10 @@ function integrateBrdfSample(nDotV, roughness, sampleCount) {
   return [scaleTerm / sampleCount, biasTerm / sampleCount];
 }
 
-function createBrdfLutUploadBytes(size = DEFAULT_BRDF_LUT_SIZE, sampleCount = 1024) {
+function createBrdfLutUploadBytes(
+  size = DEFAULT_BRDF_LUT_SIZE,
+  sampleCount = DEFAULT_BRDF_LUT_SAMPLE_COUNT
+) {
   const cacheKey = `${Math.max(1, Math.trunc(size))}:${Math.max(1, Math.trunc(sampleCount))}`;
   const cached = BRDF_LUT_UPLOAD_CACHE.get(cacheKey);
   if (cached) {
@@ -3137,6 +3263,85 @@ function createBrdfLutResource(device, constants, size = DEFAULT_BRDF_LUT_SIZE)
   });
 }
 
+function createMediumTextureResource(device, constants, mediums) {
+  const normalized = Array.isArray(mediums) && mediums.length > 0 ? mediums : [{ id: 0 }];
+  const width = Math.max(
+    1,
+    normalized.reduce((maximum, medium) => Math.max(maximum, medium.id ?? 0), 0) + 1
+  );
+  const level = {
+    width,
+    height: MEDIUM_TABLE_ROWS,
+    data: new Float32Array(width * MEDIUM_TABLE_ROWS * 4),
+  };
+
+  for (const medium of normalized) {
+    const mediumId = Math.max(0, Math.trunc(Number(medium.id) || 0));
+    const absorptionOffset = mediumId * 4;
+    level.data[absorptionOffset] = Math.max(0, medium.absorption?.[0] ?? 0);
+    level.data[absorptionOffset + 1] = Math.max(0, medium.absorption?.[1] ?? 0);
+    level.data[absorptionOffset + 2] = Math.max(0, medium.absorption?.[2] ?? 0);
+    level.data[absorptionOffset + 3] = Math.max(0, medium.phaseModel ?? 0);
+
+    const scatteringOffset = (width + mediumId) * 4;
+    level.data[scatteringOffset] = Math.max(0, medium.scattering?.[0] ?? 0);
+    level.data[scatteringOffset + 1] = Math.max(0, medium.scattering?.[1] ?? 0);
+    level.data[scatteringOffset + 2] = Math.max(0, medium.scattering?.[2] ?? 0);
+    level.data[scatteringOffset + 3] = Math.max(0, medium.density ?? 0);
+  }
+
+  const upload = createFloat16RgbaUploadFromLevels([level])[0];
+  const texture = device.createTexture({
+    label: "plasius.wavefront.mediumTable",
+    size: { width, height: MEDIUM_TABLE_ROWS },
+    format: "rgba16float",
+    usage: constants.texture.TEXTURE_BINDING | constants.texture.COPY_DST,
+  });
+  device.queue.writeTexture(
+    { texture },
+    upload.bytes,
+    { bytesPerRow: upload.bytesPerRow, rowsPerImage: upload.height },
+    { width, height: MEDIUM_TABLE_ROWS, depthOrArrayLayers: 1 }
+  );
+  return Object.freeze({
+    texture,
+    view: texture.createView(),
+    ownsTexture: true,
+    count: normalized.length,
+    width,
+  });
+}
+
+function mediumTablesEqual(left, right) {
+  const leftMediums = Array.isArray(left) ? left : [];
+  const rightMediums = Array.isArray(right) ? right : [];
+  if (leftMediums.length !== rightMediums.length) {
+    return false;
+  }
+  for (let index = 0; index < leftMediums.length; index += 1) {
+    const leftMedium = leftMediums[index];
+    const rightMedium = rightMediums[index];
+    if ((leftMedium?.id ?? 0) !== (rightMedium?.id ?? 0)) {
+      return false;
+    }
+    if ((leftMedium?.phaseModel ?? 0) !== (rightMedium?.phaseModel ?? 0)) {
+      return false;
+    }
+    if ((leftMedium?.density ?? 0) !== (rightMedium?.density ?? 0)) {
+      return false;
+    }
+    for (let component = 0; component < 3; component += 1) {
+      if ((leftMedium?.absorption?.[component] ?? 0) !== (rightMedium?.absorption?.[component] ?? 0)) {
+        return false;
+      }
+      if ((leftMedium?.scattering?.[component] ?? 0) !== (rightMedium?.scattering?.[component] ?? 0)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 function createAtlasTextureResource(device, constants, atlas, label) {
   const upload = createRgba8TextureUpload(atlas);
   const texture = device.createTexture({
@@ -3283,6 +3488,10 @@ struct SceneObject {
   objectId: u32,
   materialKind: u32,
   flags: u32,
+  mediumRefId: u32,
+  pad0: u32,
+  pad1: u32,
+  pad2: u32,
   center: vec4<f32>,
   halfExtent: vec4<f32>,
   color: vec4<f32>,
@@ -3343,9 +3552,9 @@ struct BvhLeafRef {
 struct ScatterResult {
   direction: vec4<f32>,
   pdf: f32,
+  mediumRefId: u32,
   flags: u32,
   pad0: u32,
-  pad1: u32,
 };
 
 struct MeshVertex {
@@ -3491,6 +3700,7 @@ struct EnvironmentPortal {
 @group(0) @binding(29) var brdfLutTexture: texture_2d<f32>;
 @group(0) @binding(30) var brdfLutSampler: sampler;
 @group(0) @binding(31) var environmentSamplingTexture: texture_2d<f32>;
+@group(0) @binding(32) var mediumTableTexture: texture_2d<f32>;
 
 fn hash_u32(value: u32) -> u32 {
   var x = value;
@@ -4156,6 +4366,60 @@ fn gated_environment_radiance(origin: vec3<f32>, direction: vec3<f32>) -> vec3<f
   return environment_radiance(origin, direction);
 }
 
+fn medium_dimensions() -> vec2<u32> {
+  return textureDimensions(mediumTableTexture);
+}
+
+fn medium_valid(mediumRefId: u32) -> bool {
+  let dimensions = medium_dimensions();
+  return mediumRefId > 0u && mediumRefId < dimensions.x;
+}
+
+fn medium_absorption(mediumRefId: u32) -> vec3<f32> {
+  if (!medium_valid(mediumRefId)) {
+    return vec3<f32>(0.0);
+  }
+  return max(
+    textureLoad(mediumTableTexture, vec2<i32>(i32(mediumRefId), 0), 0).xyz,
+    vec3<f32>(0.0)
+  );
+}
+
+fn medium_scattering(mediumRefId: u32) -> vec3<f32> {
+  if (!medium_valid(mediumRefId)) {
+    return vec3<f32>(0.0);
+  }
+  return max(
+    textureLoad(mediumTableTexture, vec2<i32>(i32(mediumRefId), 1), 0).xyz,
+    vec3<f32>(0.0)
+  );
+}
+
+fn medium_transmittance(mediumRefId: u32, distance: f32) -> vec3<f32> {
+  if (!medium_valid(mediumRefId) || distance <= 0.000001) {
+    return vec3<f32>(1.0);
+  }
+  let extinction = medium_absorption(mediumRefId) + medium_scattering(mediumRefId);
+  return vec3<f32>(
+    exp(-extinction.x * distance),
+    exp(-extinction.y * distance),
+    exp(-extinction.z * distance)
+  );
+}
+
+fn transmitted_medium_ref_id(ray: RayRecord, hit: HitRecord) -> u32 {
+  if (hit.mediumRefId == 0u) {
+    return ray.mediumRefId;
+  }
+  if (hit.frontFace == 1u) {
+    return hit.mediumRefId;
+  }
+  if (ray.mediumRefId == hit.mediumRefId) {
+    return 0u;
+  }
+  return ray.mediumRefId;
+}
+
 fn surface_path_response(hit: HitRecord) -> vec3<f32> {
   let color = clamp(hit.color.xyz, vec3<f32>(0.0), vec3<f32>(1.0));
   let opacity = clamp(hit.material.z, 0.0, 1.0);
@@ -4254,11 +4518,15 @@ fn terminal_surface_environment_source(ray: RayRecord, hit: HitRecord) -> vec3<f
   return clamp_sample_radiance(environmentFloor * materialFloor);
 }
 
-fn terminal_surface_environment_contribution(ray: RayRecord, hit: HitRecord) -> vec3<f32> {
+fn terminal_surface_environment_contribution(
+  ray: RayRecord,
+  throughput: vec3<f32>,
+  hit: HitRecord
+) -> vec3<f32> {
   let surfaceColor = max(hit.color.xyz, config.ambientColor.xyz);
   let occlusion = mix(0.75, 1.0, clamp(hit.occlusion, 0.0, 1.0));
   return clamp_sample_radiance(
-    ray.throughput.xyz *
+    throughput *
     surfaceColor *
     terminal_surface_environment_source(ray, hit) *
     occlusion
@@ -4732,7 +5000,7 @@ fn intersect_sphere(ray: RayRecord, object: SceneObject) -> Candidate {
     0xffffffffu,
     object.objectId,
     object.objectId,
-    0u
+    object.mediumRefId
   );
 }
 
@@ -4784,7 +5052,7 @@ fn intersect_box(ray: RayRecord, object: SceneObject) -> Candidate {
     0xffffffffu,
     object.objectId,
     object.objectId,
-    0u
+    object.mediumRefId
   );
 }
 
@@ -5035,6 +5303,10 @@ fn intersectActiveQueue(@builtin(global_invocation_id) globalId: vec3<u32>) {
   let ray = activeQueue[index];
   var nearest = 1000000.0;
   var hitObject = SceneObject(
+    0u,
+    0u,
+    0u,
+    0u,
     0u,
     0u,
     0u,
@@ -5238,9 +5510,9 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord, seed: u32) -> ScatterResult
     return ScatterResult(
       vec4<f32>(reflect(ray.direction.xyz, normal), 0.0),
       1.0,
+      ray.mediumRefId,
       RAY_FLAG_DELTA_SAMPLE,
       0u,
-      0u
     );
   }
 
@@ -5260,17 +5532,17 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord, seed: u32) -> ScatterResult
       return ScatterResult(
         vec4<f32>(reflect(ray.direction.xyz, normal), 0.0),
         1.0,
+        ray.mediumRefId,
         RAY_FLAG_DELTA_SAMPLE,
         0u,
-        0u
       );
     }
     return ScatterResult(
       vec4<f32>(refract_direction(ray.direction.xyz, normal, etaRatio), 0.0),
       1.0,
+      transmitted_medium_ref_id(ray, hit),
       RAY_FLAG_DELTA_SAMPLE,
       0u,
-      0u
     );
   }
 
@@ -5285,9 +5557,9 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord, seed: u32) -> ScatterResult
       return ScatterResult(
         vec4<f32>(guidedDirection, 0.0),
         guidedPdf,
+        ray.mediumRefId,
         RAY_FLAG_GUIDED_EMISSIVE,
         0u,
-        0u
       );
     }
   }
@@ -5295,7 +5567,7 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord, seed: u32) -> ScatterResult
     let guidedDirection = sample_environment_portal_direction(hit, seed + 131u, normal);
     if (dot(normal, guidedDirection) > 0.000001) {
       let guidedPdf = max(evaluate_surface_bsdf_pdf(hit, viewDirection, guidedDirection), 0.000001);
-      return ScatterResult(vec4<f32>(guidedDirection, 0.0), guidedPdf, 0u, 0u, 0u);
+      return ScatterResult(vec4<f32>(guidedDirection, 0.0), guidedPdf, ray.mediumRefId, 0u, 0u);
     }
   }
 
@@ -5329,7 +5601,7 @@ fn scatter_direction(ray: RayRecord, hit: HitRecord, seed: u32) -> ScatterResult
     );
   }
   let pdf = max(evaluate_surface_bsdf_pdf(hit, viewDirection, lightDirection), 0.000001);
-  return ScatterResult(vec4<f32>(lightDirection, 0.0), pdf, 0u, 0u, 0u);
+  return ScatterResult(vec4<f32>(lightDirection, 0.0), pdf, ray.mediumRefId, 0u, 0u);
 }
 
 @compute @workgroup_size(64)
@@ -5342,15 +5614,17 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
 
   let ray = activeQueue[index];
   let hit = hits[index];
+  let segmentTransmittance = medium_transmittance(ray.mediumRefId, hit.distance);
+  let arrivingThroughput = ray.throughput.xyz * segmentTransmittance;
   var contribution = vec3<f32>(0.0);
 
   if (hit.hitType == 1u) {
     let guidedLightWeight = select(1.0, 0.24, (ray.flags & RAY_FLAG_GUIDED_EMISSIVE) != 0u);
     let sourceRadiance = max(hit.emission.xyz, hit.color.xyz) * guidedLightWeight;
     if (deferred_path_resolve_enabled()) {
-      record_deferred_terminal_source(ray, sourceRadiance);
+      record_deferred_terminal_source(ray, sourceRadiance * segmentTransmittance);
     } else {
-      contribution = clamp_sample_radiance(ray.throughput.xyz * sourceRadiance);
+      contribution = clamp_sample_radiance(arrivingThroughput * sourceRadiance);
       accumulation[ray.rayId] =
         accumulation[ray.rayId] + vec4<f32>(contribution * sample_weight(), 1.0);
     }
@@ -5367,9 +5641,9 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
       sourceRadiance = sourceRadiance * misWeight;
     }
     if (deferred_path_resolve_enabled()) {
-      record_deferred_terminal_source(ray, sourceRadiance);
+      record_deferred_terminal_source(ray, sourceRadiance * segmentTransmittance);
     } else {
-      contribution = clamp_sample_radiance(ray.throughput.xyz * sourceRadiance);
+      contribution = clamp_sample_radiance(arrivingThroughput * sourceRadiance);
       accumulation[ray.rayId] =
         accumulation[ray.rayId] + vec4<f32>(contribution * sample_weight(), 1.0);
     }
@@ -5377,7 +5651,11 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     return;
   }
 
-  let response = stabilize_surface_path_response(ray, hit, surface_path_response(hit));
+  let response = stabilize_surface_path_response(
+    ray,
+    hit,
+    surface_path_response(hit) * segmentTransmittance
+  );
   record_deferred_path_response(ray, response);
 
   let shouldEstimateDirectEnvironment =
@@ -5385,7 +5663,22 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     hit.material.z >= 0.95 &&
     ray.bounce < 2u;
   if (shouldEstimateDirectEnvironment) {
-    let directEnvironment = surface_direct_environment_contribution(ray, hit);
+    let directEnvironment = surface_direct_environment_contribution(
+      RayRecord(
+        ray.rayId,
+        ray.parentRayId,
+        ray.sourcePixelId,
+        ray.sampleId,
+        ray.bounce,
+        ray.mediumRefId,
+        ray.flags,
+        0u,
+        ray.origin,
+        ray.direction,
+        vec4<f32>(arrivingThroughput, ray.throughput.w)
+      ),
+      hit
+    );
     accumulation[ray.rayId] =
       accumulation[ray.rayId] + vec4<f32>(directEnvironment * sample_weight(), 0.0);
   }
@@ -5394,7 +5687,11 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     if (deferred_path_resolve_enabled()) {
       record_deferred_terminal_source(ray, terminal_surface_environment_source(ray, hit));
     } else {
-      let terminalEnvironment = terminal_surface_environment_contribution(ray, hit);
+      let terminalEnvironment = terminal_surface_environment_contribution(
+        ray,
+        arrivingThroughput,
+        hit
+      );
       accumulation[ray.rayId] =
         accumulation[ray.rayId] + vec4<f32>(terminalEnvironment * sample_weight(), 1.0);
     }
@@ -5409,7 +5706,11 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     if (deferred_path_resolve_enabled()) {
       record_deferred_terminal_source(ray, terminal_surface_environment_source(ray, hit));
     } else {
-      let overflowEnvironment = terminal_surface_environment_contribution(ray, hit);
+      let overflowEnvironment = terminal_surface_environment_contribution(
+        ray,
+        arrivingThroughput,
+        hit
+      );
       accumulation[ray.rayId] =
         accumulation[ray.rayId] + vec4<f32>(overflowEnvironment * sample_weight(), 1.0);
     }
@@ -5423,7 +5724,7 @@ fn resolveSurfaceRecords(@builtin(global_invocation_id) globalId: vec3<u32>) {
     ray.sourcePixelId,
     ray.sampleId,
     ray.bounce + 1u,
-    ray.mediumRefId,
+    scatter.mediumRefId,
     scatter.flags,
     0u,
     vec4<f32>(offset_origin(hit.position.xyz, hit.shadingNormal.xyz), 1.0),
@@ -5694,9 +5995,28 @@ function nowMs() {
   return Date.now();
 }
 
-function estimateSubmittedGpuWorkTimeoutMs(config, tileCount, overrideTimeoutMs = null) {
+function estimateAccelerationBuildWaitFactor(config) {
+  if (config?.gpuAccelerationBuildRequired !== true) {
+    return 1;
+  }
+  const bvhSortStageCount = Array.isArray(config?.bvhSortStages) ? config.bvhSortStages.length : 0;
+  const bvhBuildLevelCount = Array.isArray(config?.bvhBuildLevels) ? config.bvhBuildLevels.length : 0;
+  const accelerationStageCount = 2 + bvhSortStageCount + bvhBuildLevelCount;
+  return Math.max(1, 1 + accelerationStageCount / 96);
+}
+
+function estimateSubmittedGpuWorkTiming(
+  config,
+  tileCount,
+  overrideTimeoutMs = null,
+  options = {}
+) {
   if (Number.isFinite(overrideTimeoutMs)) {
-    return Math.max(1, Math.trunc(Number(overrideTimeoutMs)));
+    const overrideMs = Math.max(1, Math.trunc(Number(overrideTimeoutMs)));
+    return Object.freeze({
+      timeoutMs: overrideMs,
+      maxWaitMs: overrideMs,
+    });
   }
   const samplesPerPixel = Math.max(
     1,
@@ -5708,10 +6028,28 @@ function estimateSubmittedGpuWorkTimeoutMs(config, tileCount, overrideTimeoutMs
   const tiles = Math.max(1, Number(tileCount ?? 1));
   const estimatedPasses =
     tiles * (samplesPerPixel * (maxDepth + 1 + deferredResolvePasses) + denoisePasses + 1);
-  return Math.min(
+  const triangleCount = Math.max(0, Number(config?.triangleCount ?? 0));
+  const geometryFactor = Math.max(1, triangleCount / 131072);
+  const includeAccelerationBuild = options.includeAccelerationBuild === true;
+  const accelerationFactor = includeAccelerationBuild
+    ? estimateAccelerationBuildWaitFactor(config)
+    : 1;
+  const estimatedWindowMs = Math.round(
+    (GPU_SUBMITTED_WORK_TIMEOUT_MS + estimatedPasses * 5) * geometryFactor * accelerationFactor
+  );
+  const timeoutMs = Math.min(
     GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS,
-    GPU_SUBMITTED_WORK_TIMEOUT_MS + estimatedPasses * 5
+    Math.max(GPU_SUBMITTED_WORK_TIMEOUT_MS, estimatedWindowMs)
+  );
+  const maxWaitMultiplier = includeAccelerationBuild ? 3 : 2;
+  const maxWaitMs = Math.min(
+    GPU_MAX_SUBMITTED_WORK_DEADLINE_MS,
+    Math.max(timeoutMs, estimatedWindowMs * maxWaitMultiplier)
   );
+  return Object.freeze({
+    timeoutMs,
+    maxWaitMs,
+  });
 }
 
 export async function createWavefrontPathTracingComputeRenderer(options = {}) {
@@ -5945,6 +6283,11 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
     config.environmentMap,
     config.environmentColor
   );
+  let mediumTextureResource = createMediumTextureResource(
+    device,
+    constants,
+    config.mediums
+  );
   config = Object.freeze({
     ...config,
     environmentMap: Object.freeze({
@@ -6033,6 +6376,7 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       { binding: 29, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
       { binding: 30, visibility: constants.shader.COMPUTE, sampler: { type: "filtering" } },
       { binding: 31, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 32, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
     ],
   });
   const accelerationBindGroupLayout = device.createBindGroupLayout({
@@ -6222,14 +6566,19 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
         { binding: 29, resource: brdfLutResource.view },
         { binding: 30, resource: brdfLutResource.sampler },
         { binding: 31, resource: environmentSamplingResource.view },
+        { binding: 32, resource: mediumTextureResource.view },
       ],
     });
   }
 
-  const bindGroups = [
-    createTraceBindGroup(activeQueue, nextQueue, "plasius.wavefront.bind.activeNext"),
-    createTraceBindGroup(nextQueue, activeQueue, "plasius.wavefront.bind.nextActive"),
-  ];
+  function createTraceBindGroups() {
+    return [
+      createTraceBindGroup(activeQueue, nextQueue, "plasius.wavefront.bind.activeNext"),
+      createTraceBindGroup(nextQueue, activeQueue, "plasius.wavefront.bind.nextActive"),
+    ];
+  }
+
+  let bindGroups = createTraceBindGroups();
   const bvhBuildBindGroup = device.createBindGroup({
     label: "plasius.wavefront.bind.bvhBuild",
     layout: accelerationBindGroupLayout,
@@ -6418,6 +6767,7 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       emissiveTriangleCount: config.emissiveTriangleCount,
       environmentPortalCount: config.environmentPortalCount,
       environmentPortalMode: config.environmentPortalMode,
+      mediumCount: config.mediumCount,
       environmentMap: createEnvironmentMapSnapshot(config.environmentMap),
       deferredPathResolve: config.deferredPathResolve,
       bvhNodeCount: config.bvhNodeCount,
@@ -6730,6 +7080,10 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
         ? Number(options.timeoutMs)
         : GPU_SUBMITTED_WORK_TIMEOUT_MS
     );
+    const maxWaitMs = Math.max(
+      timeoutMs,
+      Number.isFinite(options.maxWaitMs) ? Number(options.maxWaitMs) : timeoutMs
+    );
     const allowTimeout = options.allowTimeout !== false;
     const completionPromise = device.queue.onSubmittedWorkDone().then(
       () => ({ status: "done" }),
@@ -6745,47 +7099,62 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
             );
           })
         : null;
-    let timeoutHandle = null;
-    let resolveTimeoutPromise = null;
-    let timeoutSettled = false;
-    const settleTimeoutPromise = (value) => {
-      if (timeoutSettled) {
-        return;
+    const startedAtMs = nowMs();
+    while (true) {
+      const elapsedMs = Math.max(0, nowMs() - startedAtMs);
+      const remainingMs = Math.max(0, maxWaitMs - elapsedMs);
+      if (remainingMs <= 0) {
+        if (!allowTimeout) {
+          throw new Error(`Timed out after ${Math.round(maxWaitMs)} ms waiting for submitted GPU work.`);
+        }
+        console.warn(
+          `[plasius.wavefront] Submitted GPU work did not report completion within ${Math.round(maxWaitMs)} ms; continuing.`
+        );
+        return false;
       }
-      timeoutSettled = true;
-      resolveTimeoutPromise?.(value);
-    };
-    const timeoutPromise = new Promise((resolve) => {
-      resolveTimeoutPromise = resolve;
-      timeoutHandle = setTimeout(() => settleTimeoutPromise({ status: "timeout" }), timeoutMs);
-    });
-    let result;
-    try {
-      result = await Promise.race(
-        [completionPromise, timeoutPromise, lossPromise].filter(Boolean)
-      );
-    } finally {
-      if (timeoutHandle !== null) {
-        clearTimeout(timeoutHandle);
-        settleTimeoutPromise({ status: "cancelled" });
+      const waitWindowMs = Math.max(1, Math.min(timeoutMs, remainingMs));
+      let timeoutHandle = null;
+      let resolveTimeoutPromise = null;
+      let timeoutSettled = false;
+      const settleTimeoutPromise = (value) => {
+        if (timeoutSettled) {
+          return;
+        }
+        timeoutSettled = true;
+        resolveTimeoutPromise?.(value);
+      };
+      const timeoutPromise = new Promise((resolve) => {
+        resolveTimeoutPromise = resolve;
+        timeoutHandle = setTimeout(
+          () => settleTimeoutPromise({ status: "timeout" }),
+          waitWindowMs
+        );
+      });
+      let result;
+      try {
+        result = await Promise.race(
+          [completionPromise, timeoutPromise, lossPromise].filter(Boolean)
+        );
+      } finally {
+        if (timeoutHandle !== null) {
+          clearTimeout(timeoutHandle);
+          settleTimeoutPromise({ status: "cancelled" });
+        }
       }
-    }
-    if (result?.status === "timeout") {
-      if (!allowTimeout) {
-        throw new Error(`Timed out after ${timeoutMs} ms waiting for submitted GPU work.`);
+      if (result?.status === "done") {
+        return true;
+      }
+      if (result?.status !== "timeout") {
+        return true;
       }
-      console.warn(
-        `[plasius.wavefront] Submitted GPU work did not report completion within ${timeoutMs} ms; continuing.`
-      );
-      return false;
     }
-    return true;
   }
 
   function dispatchFrameAwaitingGpu(
     frameIndex,
     parallelism,
-    renderedSamplesPerPixel = config.samplesPerPixel
+    renderedSamplesPerPixel = config.samplesPerPixel,
+    optionsForFrame = {}
   ) {
     const samplePassesPerSample = config.maxDepth + 1 + (config.deferredPathResolve ? 1 : 0);
     const denoisePassCount = config.denoise ? (renderedSamplesPerPixel < 4 ? 2 : 1) : 0;
@@ -6794,25 +7163,50 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       1,
       Math.floor(
         Math.max(config.maxFramePassesPerSubmission - tailPassCount, 1) /
-          Math.max(samplePassesPerSample, 1)
+        Math.max(samplePassesPerSample, 1)
       )
     );
-    let submissionCount = 0;
+    const sampleRangeStart = clamp(
+      readNonNegativeInteger("sampleRangeStart", optionsForFrame.sampleRangeStart, 0),
+      0,
+      renderedSamplesPerPixel
+    );
+    const sampleRangeEnd = clamp(
+      readPositiveInteger("sampleRangeEnd", optionsForFrame.sampleRangeEnd, renderedSamplesPerPixel),
+      sampleRangeStart,
+      renderedSamplesPerPixel
+    );
+    const includeDenoise = optionsForFrame.includeDenoise === true;
+    const includePresent = optionsForFrame.includePresent === true;
+    const tileStartIndex = clamp(
+      readNonNegativeInteger("tileStartIndex", optionsForFrame.tileStartIndex, 0),
+      0,
+      tiles.length
+    );
+    const tileEndIndex = clamp(
+      readPositiveInteger("tileEndIndex", optionsForFrame.tileEndIndex, tiles.length),
+      tileStartIndex,
+      tiles.length
+    );
+    let submissionCount = Math.max(
+      0,
+      readNonNegativeInteger("startingSubmissionCount", optionsForFrame.startingSubmissionCount, 0)
+    );
+    let slot = Math.max(0, readNonNegativeInteger("startingSlot", optionsForFrame.startingSlot, 0));
 
-    for (const tile of tiles) {
+    for (const tile of tiles.slice(tileStartIndex, tileEndIndex)) {
       for (
-        let sampleStart = 0;
-        sampleStart < renderedSamplesPerPixel;
+        let sampleStart = sampleRangeStart;
+        sampleStart < sampleRangeEnd;
         sampleStart += sampleBatchSize
       ) {
-        const sampleEnd = Math.min(renderedSamplesPerPixel, sampleStart + sampleBatchSize);
+        const sampleEnd = Math.min(sampleRangeEnd, sampleStart + sampleBatchSize);
         const batch = createGpuSubmissionBatcher({
           device,
           frameIndex,
           maxFramePassesPerSubmission: config.maxFramePassesPerSubmission,
           startingSubmissionCount: submissionCount,
         });
-        let slot = 0;
         for (let sampleIndex = sampleStart; sampleIndex < sampleEnd; sampleIndex += 1) {
           const configOffset = writeFrameConfigSlot(slot, tile, frameIndex, {
             sampleIndex,
@@ -6829,11 +7223,12 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
             encodeTileOutput(batch.reserve(1), tile, configOffset, parallelism);
           }
         }
-        if (!config.deferredPathResolve && sampleEnd >= renderedSamplesPerPixel) {
+        if (!config.deferredPathResolve && sampleRangeEnd >= renderedSamplesPerPixel) {
           const outputConfigOffset = writeFrameConfigSlot(slot, tile, frameIndex, {
             sampleIndex: 0,
             sampleWeight: 1 / renderedSamplesPerPixel,
           });
+          slot += 1;
           encodeTileOutput(batch.reserve(1), tile, outputConfigOffset, parallelism);
         }
         batch.flush();
@@ -6841,30 +7236,38 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       }
     }
 
-    const tail = createGpuSubmissionBatcher({
-      device,
-      frameIndex,
-      maxFramePassesPerSubmission: config.maxFramePassesPerSubmission,
-      startingSubmissionCount: submissionCount,
-    });
-    if (config.denoise) {
-      const denoiseConfigOffset = writeFrameConfigSlot(
-        0,
-        { x: 0, y: 0, width: config.width, height: config.height },
+    if (includeDenoise || includePresent) {
+      const tail = createGpuSubmissionBatcher({
+        device,
         frameIndex,
-        { sampleIndex: 0, sampleWeight: 1 / renderedSamplesPerPixel }
-      );
-      encodeDenoise(
-        tail.reserve(denoisePassCount),
-        denoiseConfigOffset,
-        parallelism,
-        renderedSamplesPerPixel
-      );
+        maxFramePassesPerSubmission: config.maxFramePassesPerSubmission,
+        startingSubmissionCount: submissionCount,
+      });
+      if (includeDenoise && config.denoise) {
+        const denoiseConfigOffset = writeFrameConfigSlot(
+          slot,
+          { x: 0, y: 0, width: config.width, height: config.height },
+          frameIndex,
+          { sampleIndex: 0, sampleWeight: 1 / renderedSamplesPerPixel }
+        );
+        slot += 1;
+        encodeDenoise(
+          tail.reserve(denoisePassCount),
+          denoiseConfigOffset,
+          parallelism,
+          renderedSamplesPerPixel
+        );
+      }
+      if (includePresent) {
+        encodePresent(tail.reserve(1));
+      }
+      tail.flush();
+      submissionCount += tail.getSubmissionCount();
     }
-    encodePresent(tail.reserve(1));
-    tail.flush();
-    submissionCount += tail.getSubmissionCount();
-    return submissionCount;
+    return Object.freeze({
+      submissionCount,
+      slot,
+    });
   }
 
   async function readOutputProbe(optionsForProbe = {}) {
@@ -6913,26 +7316,59 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
     const samplingPlan = resolveRenderedSamplesPerPixel(renderOptions, awaitGPUCompletion);
     const useThrottledHighSamplePath =
       awaitGPUCompletion && samplingPlan.renderedSamplesPerPixel >= 8;
-    const submittedWorkTimeoutMs = estimateSubmittedGpuWorkTimeoutMs(
-      { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
-      tiles.length,
-      renderOptions.submittedWorkTimeoutMs
-    );
     const frameStartTimeMs = nowMs();
-    const submissionWaitOptions = awaitGPUCompletion
-      ? { timeoutMs: submittedWorkTimeoutMs, allowTimeout: false }
-      : { timeoutMs: submittedWorkTimeoutMs };
     let frameStats;
     if (useThrottledHighSamplePath) {
       frame += 1;
       const frameIndex = frame + config.frameIndex;
       const parallelismCounters = createGpuParallelismCounters();
       const accelerationBuildSubmitted = dispatchGpuAccelerationBuild(frameIndex, parallelismCounters);
-      const frameSubmissionCount = dispatchFrameAwaitingGpu(
-        frameIndex,
-        parallelismCounters,
-        samplingPlan.renderedSamplesPerPixel
-      );
+      let frameSubmissionCount = 0;
+      let frameConfigSlot = 0;
+      if (accelerationBuildSubmitted) {
+        const accelerationWaitOptions = {
+          ...estimateSubmittedGpuWorkTiming(
+            { ...config, renderedSamplesPerPixel: 1 },
+            1,
+            renderOptions.submittedWorkTimeoutMs,
+            { includeAccelerationBuild: true }
+          ),
+          allowTimeout: false,
+        };
+        await waitForSubmittedGpuWork(accelerationWaitOptions);
+      }
+      for (let tileIndex = 0; tileIndex < tiles.length; tileIndex += 1) {
+        const tileRangeDispatch = dispatchFrameAwaitingGpu(
+          frameIndex,
+          parallelismCounters,
+          samplingPlan.renderedSamplesPerPixel,
+          {
+            sampleRangeStart: 0,
+            sampleRangeEnd: samplingPlan.renderedSamplesPerPixel,
+            tileStartIndex: tileIndex,
+            tileEndIndex: tileIndex + 1,
+            startingSubmissionCount: frameSubmissionCount,
+            startingSlot: frameConfigSlot,
+            includeDenoise: tileIndex + 1 >= tiles.length,
+            includePresent: tileIndex + 1 >= tiles.length,
+          }
+        );
+        frameSubmissionCount = tileRangeDispatch.submissionCount;
+        frameConfigSlot = tileRangeDispatch.slot;
+        const tileWaitOptions = {
+          ...estimateSubmittedGpuWorkTiming(
+            { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
+            1,
+            renderOptions.submittedWorkTimeoutMs,
+            {
+              includeDenoise: tileIndex + 1 >= tiles.length && config.denoise,
+              includePresent: tileIndex + 1 >= tiles.length,
+            }
+          ),
+          allowTimeout: false,
+        };
+        await waitForSubmittedGpuWork(tileWaitOptions);
+      }
       frameStats = createFrameStats({
         frameIndex,
         accelerationBuildSubmitted,
@@ -6944,10 +7380,26 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
         budgetConstrained: samplingPlan.budgetConstrained,
       });
     } else {
+      const submittedWorkTiming = estimateSubmittedGpuWorkTiming(
+        { ...config, renderedSamplesPerPixel: samplingPlan.renderedSamplesPerPixel },
+        tiles.length,
+        renderOptions.submittedWorkTimeoutMs,
+        { includeAccelerationBuild: config.gpuAccelerationBuildRequired && !accelerationBuilt }
+      );
+      const submissionWaitOptions = awaitGPUCompletion
+        ? {
+            timeoutMs: submittedWorkTiming.timeoutMs,
+            maxWaitMs: submittedWorkTiming.maxWaitMs,
+            allowTimeout: false,
+          }
+        : {
+            timeoutMs: submittedWorkTiming.timeoutMs,
+            maxWaitMs: submittedWorkTiming.maxWaitMs,
+          };
       frameStats = renderOnce(renderOptions, samplingPlan);
-    }
-    if (awaitGPUCompletion) {
-      await waitForSubmittedGpuWork(submissionWaitOptions);
+      if (awaitGPUCompletion) {
+        await waitForSubmittedGpuWork(submissionWaitOptions);
+      }
     }
     const frameTimeMs = Math.max(0, nowMs() - frameStartTimeMs);
     if (awaitGPUCompletion) {
@@ -7007,10 +7459,23 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
     });
   }
 
+  function rebuildMediumResources(nextConfig) {
+    const previousMediumTextureResource = mediumTextureResource;
+    mediumTextureResource = createMediumTextureResource(device, constants, nextConfig.mediums);
+    bindGroups = createTraceBindGroups();
+    if (previousMediumTextureResource?.ownsTexture) {
+      previousMediumTextureResource.texture?.destroy?.();
+    }
+  }
+
   function updateSceneObjects(sceneObjects) {
     const nextPackedScene = packWavefrontSceneObjects(sceneObjects, config.sceneObjectCapacity);
     packedScene = nextPackedScene;
-    config = rebuildLiveConfig();
+    const nextConfig = rebuildLiveConfig();
+    if (!mediumTablesEqual(config.mediums, nextConfig.mediums)) {
+      rebuildMediumResources(nextConfig);
+    }
+    config = nextConfig;
     device.queue.writeBuffer(sceneObjectBuffer, 0, packedScene.buffer);
     return config;
   }
@@ -7036,6 +7501,7 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       emissiveTriangleCount: config.emissiveTriangleCount,
       environmentPortalCount: config.environmentPortalCount,
       environmentPortalMode: config.environmentPortalMode,
+      mediumCount: config.mediumCount,
       environmentMap: createEnvironmentMapSnapshot(config.environmentMap),
       deferredPathResolve: config.deferredPathResolve,
       bvhNodeCount: config.bvhNodeCount,
@@ -7070,17 +7536,20 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
     activeDispatchBuffer.destroy?.();
     radianceTexture.destroy?.();
     denoiseScratchTexture.destroy?.();
-        outputTexture.destroy?.();
-        if (environmentMapResource.ownsTexture) {
-          environmentMapResource.texture?.destroy?.();
-        }
-        if (environmentSamplingResource.ownsTexture) {
-          environmentSamplingResource.texture?.destroy?.();
-        }
-        brdfLutResource.texture?.destroy?.();
-        if (baseColorAtlasResource.ownsTexture) {
-          baseColorAtlasResource.texture?.destroy?.();
-        }
+    outputTexture.destroy?.();
+    if (environmentMapResource.ownsTexture) {
+      environmentMapResource.texture?.destroy?.();
+    }
+    if (environmentSamplingResource.ownsTexture) {
+      environmentSamplingResource.texture?.destroy?.();
+    }
+    if (mediumTextureResource.ownsTexture) {
+      mediumTextureResource.texture?.destroy?.();
+    }
+    brdfLutResource.texture?.destroy?.();
+    if (baseColorAtlasResource.ownsTexture) {
+      baseColorAtlasResource.texture?.destroy?.();
+    }
     if (metallicRoughnessAtlasResource.ownsTexture) {
       metallicRoughnessAtlasResource.texture?.destroy?.();
     }