@plasius/gpu-renderer 0.2.6 → 0.2.8

package/dist/index.js

@@ -138,17 +138,19 @@ var DEFAULT_MAX_DEPTH = 6;
 var DEFAULT_TILE_SIZE = 128;
 var DEFAULT_SAMPLES_PER_PIXEL = 1;
 var MAX_SAMPLES_PER_PIXEL = 256;
-var DEFAULT_BRDF_LUT_SIZE = 256;
+var DEFAULT_BRDF_LUT_SIZE = 128;
+var DEFAULT_BRDF_LUT_SAMPLE_COUNT = 256;
 var DEFAULT_MAX_FRAME_PASSES_PER_SUBMISSION = 256;
 var DEFAULT_SCENE_OBJECT_CAPACITY = 128;
 var DEFAULT_ENVIRONMENT_PORTAL_CAPACITY = 32;
+var DEFAULT_MEDIUM_PHASE_MODEL = 0;
 var WORKGROUP_SIZE = 64;
 var rendererWavefrontComputeMode = "webgpu-compute";
 var rendererWavefrontComputeWorkgroupSize = WORKGROUP_SIZE;
 var rendererWavefrontComputeStatsStride = 8;
 var RAY_RECORD_BYTES = 80;
 var HIT_RECORD_BYTES = 256;
-var SCENE_OBJECT_RECORD_BYTES = 144;
+var SCENE_OBJECT_RECORD_BYTES = 160;
 var MESH_VERTEX_RECORD_BYTES = 48;
 var MESH_RANGE_RECORD_BYTES = 240;
 var TRIANGLE_RECORD_BYTES = 352;
@@ -157,11 +159,13 @@ var BVH_NODE_RECORD_BYTES = 48;
 var BVH_LEAF_REF_RECORD_BYTES = 16;
 var EMISSIVE_TRIANGLE_INDEX_BYTES = 4;
 var ENVIRONMENT_PORTAL_RECORD_BYTES = 96;
+var MEDIUM_TABLE_ROWS = 2;
 var ACCUMULATION_RECORD_BYTES = 16;
 var PATH_VERTEX_RECORD_BYTES = 16;
 var GPU_SUBMITTED_WORK_TIMEOUT_MS = 5e3;
 var GPU_READBACK_COMPLETION_TIMEOUT_MS = 6e4;
 var GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS = 6e4;
+var GPU_MAX_SUBMITTED_WORK_DEADLINE_MS = 18e4;
 var CONFIG_BUFFER_BYTES = 320;
 var COUNTER_DISPATCH_ARGS_OFFSET = 16;
 var INDIRECT_DISPATCH_ARGS_BYTES = 12;
@@ -503,6 +507,156 @@ 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, 1e-4, 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 = /* @__PURE__ */ 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)
+  );
+}
 function normalizeWavefrontSceneObject(input = {}, index = 0) {
   const bounds = deriveBounds(input);
   const kind = readObjectKind(input.kind ?? input.type ?? (bounds ? "box" : "sphere"));
@@ -533,12 +687,19 @@ 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 : materialKindInput === void 0 || materialKindInput === null ? transmission > 1e-3 || opacity < 0.999 ? MATERIAL_TRANSPARENT : materialKind : materialKind;
   return Object.freeze({
     id: readNonNegativeInteger("id", input.id, index + 1),
     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),
@@ -562,6 +723,7 @@ 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
   });
 }
@@ -655,6 +817,7 @@ 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 : materialKindInput === void 0 || materialKindInput === null ? transmission > 1e-3 || opacity < 0.999 ? MATERIAL_TRANSPARENT : materialKind : materialKind;
   return Object.freeze({
     id: readNonNegativeInteger("mesh id", input.id, meshIndex + 1),
@@ -671,9 +834,10 @@ 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),
@@ -695,6 +859,7 @@ 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: input.metallicRoughnessTexture ?? input.material?.metallicRoughnessTexture ?? null,
@@ -706,141 +871,9 @@ function normalizeWavefrontMesh(input = {}, meshIndex = 0) {
 function clampUnit(value) {
   return clamp(Number(value) || 0, 0, 1);
 }
-function srgbToLinear(value) {
-  const channel = clampUnit(value);
-  if (channel <= 0.04045) {
-    return channel / 12.92;
-  }
-  return ((channel + 0.055) / 1.055) ** 2.4;
-}
-function sampleTextureRgba(texture, uv = [0, 0], colorSpace = "linear") {
-  if (!texture || !Number.isFinite(texture.width) || !Number.isFinite(texture.height) || !texture.data || texture.width <= 0 || texture.height <= 0) {
-    return [1, 1, 1, 1];
-  }
-  const u = (uv[0] % 1 + 1) % 1;
-  const v = (uv[1] % 1 + 1) % 1;
-  const x = Math.min(texture.width - 1, Math.max(0, Math.round(u * (texture.width - 1))));
-  const y = Math.min(texture.height - 1, Math.max(0, Math.round((1 - v) * (texture.height - 1))));
-  const offset = (y * texture.width + x) * 4;
-  const data = texture.data;
-  const scale2 = resolveTextureSampleScale(data);
-  const defaultChannel = scale2 === 1 ? 1 : Math.round(1 / scale2);
-  const color = [
-    (data[offset] ?? defaultChannel) * scale2,
-    (data[offset + 1] ?? defaultChannel) * scale2,
-    (data[offset + 2] ?? defaultChannel) * scale2,
-    (data[offset + 3] ?? defaultChannel) * scale2
-  ];
-  if (colorSpace === "srgb") {
-    return [srgbToLinear(color[0]), srgbToLinear(color[1]), srgbToLinear(color[2]), color[3]];
-  }
-  return color;
-}
-function resolveTextureSampleScale(data) {
-  if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
-    return 1 / 255;
-  }
-  if (data instanceof Uint16Array) {
-    return 1 / 65535;
-  }
-  if (Array.isArray(data) && data.some((value) => Number(value) > 1)) {
-    return 1 / 255;
-  }
-  return 1;
-}
-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 tangent2 = normalize(cross(tangentFallback, fallbackNormal), [1, 0, 0]);
-    const bitangent2 = normalize(cross(fallbackNormal, tangent2), [0, 0, 1]);
-    return { tangent: tangent2, bitangent: bitangent2 };
-  }
-  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);
@@ -859,16 +892,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(
         Object.freeze({
@@ -882,17 +905,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
           ]),
@@ -906,7 +929,7 @@ function createMeshTriangleRecords(meshes) {
             mesh.clearcoatRoughness,
             mesh.specular,
             mesh.transmission,
-            0
+            mesh.thickness
           ]),
           specularColor: Object.freeze([
             mesh.specularColor[0] ?? 1,
@@ -914,6 +937,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)
@@ -988,9 +1032,10 @@ function buildBvh(triangles, maxLeafTriangles = 4) {
     triangles: Object.freeze(orderedTriangles)
   });
 }
-function createWavefrontMeshAcceleration(meshes = []) {
+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);
 }
 function estimateMeshSourceShape(meshes) {
@@ -1200,7 +1245,7 @@ function createWavefrontGpuMaterialSource(meshes = []) {
       mesh.clearcoatRoughness,
       mesh.specular,
       mesh.transmission,
-      0
+      mesh.thickness
     ]);
     writeVec4(floatView, byteOffset + 80, [
       mesh.specularColor[0] ?? 1,
@@ -1284,12 +1329,12 @@ function createWavefrontBvhBuildLevels(triangleCountInput) {
   return Object.freeze(levels);
 }
 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;
 }
@@ -1368,7 +1413,7 @@ function createWavefrontGpuMeshSource(meshes = [], gpuMaterialSourceInput = null
       mesh.clearcoatRoughness,
       mesh.specular,
       mesh.transmission,
-      0
+      mesh.thickness
     ]);
     writeVec4(meshFloats, floatOffset * 4 + 128, [
       mesh.specularColor[0] ?? 1,
@@ -1469,12 +1514,16 @@ function normalizeSceneObjects(sceneObjects, useDefaultScene = true) {
   const source = Array.isArray(sceneObjects) && sceneObjects.length > 0 ? sceneObjects : useDefaultScene ? createDefaultWavefrontSceneObjects() : [];
   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 [];
 }
@@ -1771,7 +1820,7 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
   const meshSourceShape = estimateMeshSourceShape(meshes);
   const gpuMaterialSource = meshes.length > 0 ? createWavefrontGpuMaterialSource(meshes) : createWavefrontGpuMaterialSource([]);
   const gpuMeshSource = meshes.length > 0 ? createWavefrontGpuMeshSource(meshes, gpuMaterialSource) : createWavefrontGpuMeshSource([]);
-  const meshAcceleration = accelerationBuildMode === "cpu-debug" ? createWavefrontMeshAcceleration(meshes) : Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
+  const meshAcceleration = accelerationBuildMode === "cpu-upload" ? createWavefrontMeshAcceleration(meshes, gpuMaterialSource) : Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
   const emissiveTriangleIndices = createWavefrontEmissiveTriangleIndexSource(
     meshes,
     options.emissiveTriangleCapacity
@@ -1781,6 +1830,7 @@ 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)
@@ -1839,6 +1889,8 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
     sceneObjects,
     sceneObjectCount: sceneObjects.length,
     sceneObjectCapacity,
+    mediums,
+    mediumCount: mediums.length,
     accelerationBuildMode,
     gpuAccelerationBuildRequired: accelerationBuildMode === "gpu" && triangleCount > 0,
     gpuMeshSource,
@@ -1940,29 +1992,30 @@ function packWavefrontSceneObjects(sceneObjects, capacity = sceneObjects.length)
     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,
@@ -2498,7 +2551,7 @@ 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) {
@@ -2870,6 +2923,80 @@ function createBrdfLutResource(device, constants, size = DEFAULT_BRDF_LUT_SIZE)
     height: upload.height
   });
 }
+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({
@@ -3008,6 +3135,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>,
@@ -3068,9 +3199,9 @@ struct BvhLeafRef {
 struct ScatterResult {
   direction: vec4<f32>,
   pdf: f32,
+  mediumRefId: u32,
   flags: u32,
   pad0: u32,
-  pad1: u32,
 };
 
 struct MeshVertex {
@@ -3216,6 +3347,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;
@@ -3881,6 +4013,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);
@@ -3979,11 +4165,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
@@ -4457,7 +4647,7 @@ fn intersect_sphere(ray: RayRecord, object: SceneObject) -> Candidate {
     0xffffffffu,
     object.objectId,
     object.objectId,
-    0u
+    object.mediumRefId
   );
 }
 
@@ -4509,7 +4699,7 @@ fn intersect_box(ray: RayRecord, object: SceneObject) -> Candidate {
     0xffffffffu,
     object.objectId,
     object.objectId,
-    0u
+    object.mediumRefId
   );
 }
 
@@ -4760,6 +4950,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,
@@ -4963,9 +5157,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
     );
   }
 
@@ -4985,17 +5179,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
     );
   }
 
@@ -5010,9 +5204,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
       );
     }
   }
@@ -5020,7 +5214,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);
     }
   }
 
@@ -5054,7 +5248,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)
@@ -5067,15 +5261,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);
     }
@@ -5092,9 +5288,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);
     }
@@ -5102,7 +5298,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 =
@@ -5110,7 +5310,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);
   }
@@ -5119,7 +5334,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);
     }
@@ -5134,7 +5353,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);
     }
@@ -5148,7 +5371,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),
@@ -5409,9 +5632,22 @@ 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,
@@ -5422,10 +5658,26 @@ function estimateSubmittedGpuWorkTimeoutMs(config, tileCount, overrideTimeoutMs
   const denoisePasses = config?.denoise ? samplesPerPixel < 4 ? 2 : 1 : 0;
   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
+  });
 }
 async function createWavefrontPathTracingComputeRenderer(options = {}) {
   assertAnalyticDisplayQualityPolicy(options);
@@ -5637,6 +5889,11 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
     config.environmentMap,
     config.environmentColor
   );
+  let mediumTextureResource = createMediumTextureResource(
+    device,
+    constants,
+    config.mediums
+  );
   config = Object.freeze({
     ...config,
     environmentMap: Object.freeze({
@@ -5723,7 +5980,8 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
       { binding: 28, visibility: constants.shader.COMPUTE, sampler: { type: "filtering" } },
       { 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: 31, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 32, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } }
     ]
   });
   const accelerationBindGroupLayout = device.createBindGroupLayout({
@@ -5910,14 +6168,18 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
         { binding: 28, resource: materialAtlasSampler },
         { binding: 29, resource: brdfLutResource.view },
         { binding: 30, resource: brdfLutResource.sampler },
-        { binding: 31, resource: environmentSamplingResource.view }
+        { 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,
@@ -6095,6 +6357,7 @@ 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,
@@ -6390,6 +6653,10 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
       1,
       Number.isFinite(options2.timeoutMs) ? Number(options2.timeoutMs) : GPU_SUBMITTED_WORK_TIMEOUT_MS
     );
+    const maxWaitMs = Math.max(
+      timeoutMs,
+      Number.isFinite(options2.maxWaitMs) ? Number(options2.maxWaitMs) : timeoutMs
+    );
     const allowTimeout = options2.allowTimeout !== false;
     const completionPromise = device.queue.onSubmittedWorkDone().then(
       () => ({ status: "done" }),
@@ -6402,43 +6669,57 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
         `WebGPU device lost while waiting for submitted work (${info?.reason ?? "unknown"}).`
       );
     }) : 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) {
+  function dispatchFrameAwaitingGpu(frameIndex, parallelism, renderedSamplesPerPixel = config.samplesPerPixel, optionsForFrame = {}) {
     const samplePassesPerSample = config.maxDepth + 1 + (config.deferredPathResolve ? 1 : 0);
     const denoisePassCount = config.denoise ? renderedSamplesPerPixel < 4 ? 2 : 1 : 0;
     const tailPassCount = denoisePassCount + 1;
@@ -6448,17 +6729,42 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
         Math.max(config.maxFramePassesPerSubmission - tailPassCount, 1) / Math.max(samplePassesPerSample, 1)
       )
     );
-    let submissionCount = 0;
-    for (const tile of tiles) {
-      for (let sampleStart = 0; sampleStart < renderedSamplesPerPixel; sampleStart += sampleBatchSize) {
-        const sampleEnd = Math.min(renderedSamplesPerPixel, sampleStart + sampleBatchSize);
+    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.slice(tileStartIndex, tileEndIndex)) {
+      for (let sampleStart = sampleRangeStart; sampleStart < sampleRangeEnd; 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,
@@ -6475,41 +6781,50 @@ 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();
         submissionCount += batch.getSubmissionCount();
       }
     }
-    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 = {}) {
     const mapMode = constants.map;
@@ -6555,24 +6870,59 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
     const awaitGPUCompletion = renderOptions.awaitGPUCompletion !== false;
     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,
@@ -6584,10 +6934,24 @@ 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) {
@@ -6642,10 +7006,22 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
       ...overrides
     });
   }
+  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;
   }
@@ -6669,6 +7045,7 @@ 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,
@@ -6709,6 +7086,9 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
     if (environmentSamplingResource.ownsTexture) {
       environmentSamplingResource.texture?.destroy?.();
     }
+    if (mediumTextureResource.ownsTexture) {
+      mediumTextureResource.texture?.destroy?.();
+    }
     brdfLutResource.texture?.destroy?.();
     if (baseColorAtlasResource.ownsTexture) {
       baseColorAtlasResource.texture?.destroy?.();