@plasius/gpu-renderer 0.2.7 → 0.2.8

package/dist/index.js

@@ -165,6 +165,7 @@ 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;
@@ -870,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);
@@ -1023,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({
@@ -1046,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
           ]),
@@ -1078,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)
@@ -1152,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) {
@@ -1448,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;
 }
@@ -1939,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
@@ -5751,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,
@@ -5764,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);
@@ -6743,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" }),
@@ -6755,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;
@@ -6801,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,
@@ -6828,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;
@@ -6908,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,
@@ -6937,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) {