@plasius/gpu-renderer 0.2.41 → 0.2.43

package/package.json

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

package/src/index.d.ts

@@ -960,12 +960,20 @@ export interface WavefrontPathTracingMemoryEstimate {
   readonly triangleBytes: number;
   readonly materialTableBytes: number;
   readonly bvhNodeBytes: number;
+  readonly bvhCombinedBytes: number;
   readonly bvhLeafReferenceBytes: number;
   readonly emissiveTriangleMetadataBytes: number;
+  readonly meshVertexBytes: number;
+  readonly meshIndexBytes: number;
+  readonly meshRangeBytes: number;
   readonly environmentPortalBytes: number;
   readonly configBytes: number;
+  readonly configBufferStride: number;
+  readonly frameConfigBytes: number;
+  readonly bvhBuildConfigBytes: number;
   readonly counterBytes: number;
   readonly indirectDispatchBytes: number;
+  readonly sceneStorageBufferBindingBytes: number;
   readonly totalHotBufferBytes: number;
 }
 
@@ -987,6 +995,7 @@ export interface WavefrontGpuParallelismDiagnostics {
     readonly maxComputeWorkgroupsPerDimension: number | null;
     readonly maxStorageBuffersPerShaderStage: number | null;
     readonly maxStorageBufferBindingSize: number | null;
+    readonly maxBufferSize: number | null;
   }>;
   readonly configuredWorkgroupSize: number;
   readonly directDispatches: number;
@@ -1279,12 +1288,27 @@ export function createWavefrontGpuMaterialSource(
 ): WavefrontGpuMaterialSource;
 export function createDefaultWavefrontSceneObjects(): readonly WavefrontSceneObject[];
 export function estimateWavefrontPathTracingMemory(options?: {
+  width?: number;
+  height?: number;
+  tileSize?: number;
+  samplesPerPixel?: number;
   tilePixelCapacity?: number;
+  maxDepth?: number;
   sceneObjectCapacity?: number;
   triangleCapacity?: number;
+  materialCapacity?: number;
   bvhNodeCapacity?: number;
   bvhLeafSortCapacity?: number;
   emissiveTriangleCapacity?: number;
+  environmentPortalCapacity?: number;
+  meshVertexCount?: number;
+  meshIndexCount?: number;
+  meshRangeCount?: number;
+  bvhSortStageCount?: number;
+  bvhBuildLevelCount?: number;
+  denoise?: boolean;
+  deferredPathResolve?: boolean;
+  minUniformBufferOffsetAlignment?: number;
 }): WavefrontPathTracingMemoryEstimate;
 export function normalizeWavefrontMesh(
   input: WavefrontMeshInput,

package/src/wavefront-compute.js

@@ -15,12 +15,12 @@ import {
   createWavefrontMeshAcceleration,
 } from "./wavefront-scene-data.js";
 import {
+  estimateWavefrontPathTracingMemoryForConfig,
   createWavefrontPathTracingComputeConfig,
   packEnvironmentPortals,
   supportsWavefrontPathTracingCompute,
 } from "./wavefront-config.js";
 import {
-  alignTo,
   clampTileSizeForDevice,
   createAtlasTextureResource,
   createBrdfLutResource,
@@ -76,11 +76,7 @@ import {
 } from "./wavefront-runtime-support.js";
 
 import {
-  ACCUMULATION_RECORD_BYTES,
-  BVH_LEAF_REF_RECORD_BYTES,
   BVH_NODE_RECORD_BYTES,
-  CONFIG_BUFFER_BYTES,
-  COUNTER_BUFFER_BYTES,
   DEFAULT_AMBIENT_COLOR,
   DEFAULT_BRDF_LUT_SAMPLE_COUNT,
   DEFAULT_BRDF_LUT_SIZE,
@@ -98,14 +94,11 @@ import {
   DEFAULT_WIDTH,
   EMISSIVE_TRIANGLE_INDEX_BYTES,
   EMPTY_TERMINATION_METRICS,
-  ENVIRONMENT_PORTAL_RECORD_BYTES,
   GPU_MATERIAL_RECORD_BYTES,
   GPU_MAX_SUBMITTED_WORK_DEADLINE_MS,
   GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS,
-  HIT_RECORD_BYTES,
   HIT_TYPE_EMISSIVE,
   HIT_TYPE_SURFACE,
-  INDIRECT_DISPATCH_ARGS_BYTES,
   MATERIAL_DIELECTRIC,
   MATERIAL_DIFFUSE,
   MATERIAL_EMISSIVE,
@@ -114,19 +107,13 @@ import {
   MAX_PATH_TRACING_DEPTH,
   MAX_SAMPLES_PER_PIXEL,
   MEDIUM_TABLE_ROWS,
-  MESH_RANGE_RECORD_BYTES,
-  MESH_VERTEX_RECORD_BYTES,
   OBJECT_KIND_BOX,
   OBJECT_KIND_SPHERE,
-  PATH_VERTEX_RECORD_BYTES,
-  RAY_RECORD_BYTES,
-  SCENE_OBJECT_RECORD_BYTES,
   TERMINAL_SOURCE_KIND_AMBIENT_MAX_DEPTH,
   TERMINAL_SOURCE_KIND_AMBIENT_QUEUE_OVERFLOW,
   TERMINAL_SOURCE_KIND_EMISSIVE,
   TERMINAL_SOURCE_KIND_ENVIRONMENT,
   TRACE_STORAGE_BUFFER_BINDINGS,
-  TRIANGLE_RECORD_BYTES,
   add,
   asColor,
   asUnitVec3,
@@ -201,7 +188,9 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
     throw new Error("Unable to acquire a WebGPU adapter for wavefront path tracing.");
   }
 
-  const device = await adapter.requestDevice(createWavefrontDeviceDescriptor(adapter, options));
+  const device = await adapter.requestDevice(
+    createWavefrontDeviceDescriptor(adapter, options, initialConfig.memory)
+  );
   const gpuAdapterParallelism = createGpuAdapterParallelismDiagnostics(adapter, device);
   const context = canvas.getContext("webgpu");
   if (!context || typeof context.configure !== "function") {
@@ -224,6 +213,10 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       tileSize: safeTileSize,
     });
   }
+  config = Object.freeze({
+    ...config,
+    memory: estimateWavefrontPathTracingMemoryForConfig(config, device.limits),
+  });
   canvas.width = config.width;
   canvas.height = config.height;
   context.configure({
@@ -233,82 +226,72 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
   });
 
   const bufferUsage = constants.buffer.STORAGE | constants.buffer.COPY_DST;
-  const rayQueueBytes = config.tilePixelCapacity * RAY_RECORD_BYTES;
-  const hitBytes = config.tilePixelCapacity * HIT_RECORD_BYTES;
-  const accumulationBytes = config.tilePixelCapacity * ACCUMULATION_RECORD_BYTES;
-  const pathVertexBytes = config.tilePixelCapacity * (config.maxDepth + 1) * PATH_VERTEX_RECORD_BYTES;
-  const activeQueue = createBuffer(device, bufferUsage, rayQueueBytes, "plasius.wavefront.activeQueue");
-  const nextQueue = createBuffer(device, bufferUsage, rayQueueBytes, "plasius.wavefront.nextQueue");
-  const hitBuffer = createBuffer(device, bufferUsage, hitBytes, "plasius.wavefront.hitBuffer");
+  const memory = config.memory;
+  const activeQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.activeQueue");
+  const nextQueue = createBuffer(device, bufferUsage, memory.queueBytes, "plasius.wavefront.nextQueue");
+  const hitBuffer = createBuffer(device, bufferUsage, memory.hitBytes, "plasius.wavefront.hitBuffer");
   const accumulationBuffer = createBuffer(
     device,
     bufferUsage,
-    accumulationBytes,
+    memory.accumulationBytes,
     "plasius.wavefront.accumulation"
   );
   const pathVertexBuffer = createBuffer(
     device,
     bufferUsage,
-    pathVertexBytes,
+    memory.pathVertexBytes,
     "plasius.wavefront.pathVertices"
   );
   const sceneObjectBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    config.sceneObjectCapacity * SCENE_OBJECT_RECORD_BYTES,
+    memory.sceneObjectBytes,
     "plasius.wavefront.sceneObjects"
   );
   const triangleBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.triangleCapacity) * TRIANGLE_RECORD_BYTES,
+    memory.triangleBytes,
     "plasius.wavefront.triangles"
   );
   const bvhNodeBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.bvhNodeCapacity + config.emissiveTriangleCapacity) *
-      BVH_NODE_RECORD_BYTES,
+    memory.bvhCombinedBytes,
     "plasius.wavefront.bvhNodes"
   );
   const meshVertexBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.gpuMeshSource.vertices.count) * MESH_VERTEX_RECORD_BYTES,
+    memory.meshVertexBytes,
     "plasius.wavefront.meshVertices"
   );
   const meshIndexBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.gpuMeshSource.indices.count) * 4,
+    memory.meshIndexBytes,
     "plasius.wavefront.meshIndices"
   );
   const meshRangeBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.gpuMeshSource.meshes.count) * MESH_RANGE_RECORD_BYTES,
+    memory.meshRangeBytes,
     "plasius.wavefront.meshRanges"
   );
   const environmentPortalBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.environmentPortalCapacity) * ENVIRONMENT_PORTAL_RECORD_BYTES,
+    memory.environmentPortalBytes,
     "plasius.wavefront.environmentPortals"
   );
   const bvhLeafRefBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST,
-    Math.max(1, config.bvhLeafSortCapacity) * BVH_LEAF_REF_RECORD_BYTES,
+    memory.bvhLeafReferenceBytes,
     "plasius.wavefront.bvhLeafRefs"
   );
   const tiles = createTiles(config.width, config.height, config.tileSize);
-  const uniformOffsetAlignment = Number(device?.limits?.minUniformBufferOffsetAlignment);
-  const configBufferStride = alignTo(
-    CONFIG_BUFFER_BYTES,
-    Number.isFinite(uniformOffsetAlignment) && uniformOffsetAlignment > 0
-      ? uniformOffsetAlignment
-      : CONFIG_BUFFER_BYTES
-  );
+  const configBufferStride = memory.configBufferStride;
   const outputConfigSlotCount = config.deferredPathResolve ? 0 : tiles.length;
   const frameConfigSlotCount = Math.max(
     1,
@@ -317,27 +300,25 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
   const configBuffer = createBuffer(
     device,
     constants.buffer.UNIFORM | constants.buffer.COPY_DST,
-    frameConfigSlotCount * configBufferStride,
+    memory.frameConfigBytes,
     "plasius.wavefront.frameConfig"
   );
-  const bvhBuildConfigSlots =
-    1 + config.bvhSortStages.length + config.bvhBuildLevels.length;
   const bvhBuildConfigBuffer = createBuffer(
     device,
     constants.buffer.UNIFORM | constants.buffer.COPY_DST,
-    Math.max(1, bvhBuildConfigSlots) * configBufferStride,
+    memory.bvhBuildConfigBytes,
     "plasius.wavefront.bvhBuildConfig"
   );
   const counterBuffer = createBuffer(
     device,
     constants.buffer.STORAGE | constants.buffer.COPY_DST | constants.buffer.COPY_SRC,
-    COUNTER_BUFFER_BYTES,
+    memory.counterBytes,
     "plasius.wavefront.counters"
   );
   const activeDispatchBuffer = createBuffer(
     device,
     constants.buffer.INDIRECT | constants.buffer.COPY_DST,
-    INDIRECT_DISPATCH_ARGS_BYTES,
+    memory.indirectDispatchBytes,
     "plasius.wavefront.activeDispatchArgs"
   );
 

package/src/wavefront-config.js

@@ -19,7 +19,6 @@ import {
   EMISSIVE_TRIANGLE_INDEX_BYTES,
   EMPTY_TERMINATION_METRICS,
   ENVIRONMENT_PORTAL_RECORD_BYTES,
-  GPU_MATERIAL_RECORD_BYTES,
   HIT_RECORD_BYTES,
   INDIRECT_DISPATCH_ARGS_BYTES,
   MAX_PATH_TRACING_DEPTH,
@@ -69,6 +68,16 @@ import {
   resolveAccelerationBuildMode,
 } from "./wavefront-scene-data.js";
 
+const WEBGPU_DEFAULT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 256;
+
+function allocatedRecordBytes(count, recordBytes) {
+  return Math.max(1, count) * recordBytes;
+}
+
+function alignByteSize(value, alignment) {
+  return Math.ceil(value / alignment) * alignment;
+}
+
 function resolveEnvironmentLighting(input, environmentColor, ambientColor) {
   const source = input ?? {};
   return Object.freeze({
@@ -257,6 +266,18 @@ function resolveCamera(input, width, height) {
 }
 
 export function estimateWavefrontPathTracingMemory(options = {}) {
+  const width = readPositiveInteger("width", options.width, DEFAULT_WIDTH);
+  const height = readPositiveInteger("height", options.height, DEFAULT_HEIGHT);
+  const tileSize = readPositiveInteger("tileSize", options.tileSize, DEFAULT_TILE_SIZE);
+  const samplesPerPixel = clamp(
+    readPositiveInteger(
+      "samplesPerPixel",
+      options.samplesPerPixel,
+      DEFAULT_SAMPLES_PER_PIXEL
+    ),
+    1,
+    MAX_SAMPLES_PER_PIXEL
+  );
   const tilePixelCapacity = readPositiveInteger(
     "tilePixelCapacity",
     options.tilePixelCapacity,
@@ -289,20 +310,106 @@ export function estimateWavefrontPathTracingMemory(options = {}) {
     options.environmentPortalCapacity,
     0
   );
-  const materialCapacity = readNonNegativeInteger("materialCapacity", options.materialCapacity, 0);
+  readNonNegativeInteger("materialCapacity", options.materialCapacity, 0);
+  const meshVertexCount = readNonNegativeInteger(
+    "meshVertexCount",
+    options.meshVertexCount,
+    0
+  );
+  const meshIndexCount = readNonNegativeInteger(
+    "meshIndexCount",
+    options.meshIndexCount,
+    0
+  );
+  const meshRangeCount = readNonNegativeInteger(
+    "meshRangeCount",
+    options.meshRangeCount,
+    0
+  );
+  const bvhSortStageCount = readNonNegativeInteger(
+    "bvhSortStageCount",
+    options.bvhSortStageCount,
+    0
+  );
+  const bvhBuildLevelCount = readNonNegativeInteger(
+    "bvhBuildLevelCount",
+    options.bvhBuildLevelCount,
+    0
+  );
+  const minUniformBufferOffsetAlignment = readPositiveInteger(
+    "minUniformBufferOffsetAlignment",
+    options.minUniformBufferOffsetAlignment,
+    WEBGPU_DEFAULT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT
+  );
+  const denoise = options.denoise !== false;
+  const deferredPathResolve = options.deferredPathResolve !== false;
   const queueBytes = tilePixelCapacity * RAY_RECORD_BYTES;
   const hitBytes = tilePixelCapacity * HIT_RECORD_BYTES;
   const accumulationBytes = tilePixelCapacity * ACCUMULATION_RECORD_BYTES;
   const pathVertexBytes = tilePixelCapacity * (maxDepth + 1) * PATH_VERTEX_RECORD_BYTES;
   const sceneObjectBytes = sceneObjectCapacity * SCENE_OBJECT_RECORD_BYTES;
-  const triangleBytes = triangleCapacity * TRIANGLE_RECORD_BYTES;
-  const materialTableBytes = materialCapacity * GPU_MATERIAL_RECORD_BYTES;
+  const triangleBytes = allocatedRecordBytes(triangleCapacity, TRIANGLE_RECORD_BYTES);
+  const materialTableBytes = 0;
   const bvhNodeBytes = bvhNodeCapacity * BVH_NODE_RECORD_BYTES;
-  const bvhLeafReferenceBytes = bvhLeafSortCapacity * BVH_LEAF_REF_RECORD_BYTES;
+  const bvhLeafReferenceBytes = allocatedRecordBytes(
+    bvhLeafSortCapacity,
+    BVH_LEAF_REF_RECORD_BYTES
+  );
   const emissiveTriangleMetadataBytes =
     emissiveTriangleCapacity * BVH_NODE_RECORD_BYTES;
-  const environmentPortalBytes =
-    environmentPortalCapacity * ENVIRONMENT_PORTAL_RECORD_BYTES;
+  const bvhCombinedBytes = allocatedRecordBytes(
+    bvhNodeCapacity + emissiveTriangleCapacity,
+    BVH_NODE_RECORD_BYTES
+  );
+  const meshVertexBytes = allocatedRecordBytes(meshVertexCount, MESH_VERTEX_RECORD_BYTES);
+  const meshIndexBytes = allocatedRecordBytes(meshIndexCount, 4);
+  const meshRangeBytes = allocatedRecordBytes(meshRangeCount, MESH_RANGE_RECORD_BYTES);
+  const environmentPortalBytes = allocatedRecordBytes(
+    environmentPortalCapacity,
+    ENVIRONMENT_PORTAL_RECORD_BYTES
+  );
+  const tileCount = Math.ceil(width / tileSize) * Math.ceil(height / tileSize);
+  const outputConfigSlotCount = deferredPathResolve ? 0 : tileCount;
+  const frameConfigSlotCount = Math.max(
+    1,
+    tileCount * samplesPerPixel + outputConfigSlotCount + (denoise ? 1 : 0)
+  );
+  const configBufferStride = alignByteSize(
+    CONFIG_BUFFER_BYTES,
+    minUniformBufferOffsetAlignment
+  );
+  const frameConfigBytes = frameConfigSlotCount * configBufferStride;
+  const bvhBuildConfigBytes = Math.max(
+    1,
+    1 + bvhSortStageCount + bvhBuildLevelCount
+  ) * configBufferStride;
+  const sceneStorageBufferBindingBytes = Math.max(
+    sceneObjectBytes,
+    triangleBytes,
+    bvhCombinedBytes,
+    meshVertexBytes,
+    meshIndexBytes,
+    meshRangeBytes,
+    environmentPortalBytes,
+    bvhLeafReferenceBytes
+  );
+  const totalHotBufferBytes =
+    queueBytes * 2 +
+    hitBytes +
+    accumulationBytes +
+    pathVertexBytes +
+    sceneObjectBytes +
+    triangleBytes +
+    bvhCombinedBytes +
+    meshVertexBytes +
+    meshIndexBytes +
+    meshRangeBytes +
+    bvhLeafReferenceBytes +
+    environmentPortalBytes +
+    frameConfigBytes +
+    bvhBuildConfigBytes +
+    COUNTER_BUFFER_BYTES +
+    INDIRECT_DISPATCH_ARGS_BYTES;
 
   return Object.freeze({
     queueBytes,
@@ -314,27 +421,48 @@ export function estimateWavefrontPathTracingMemory(options = {}) {
     triangleBytes,
     materialTableBytes,
     bvhNodeBytes,
+    bvhCombinedBytes,
     bvhLeafReferenceBytes,
     emissiveTriangleMetadataBytes,
+    meshVertexBytes,
+    meshIndexBytes,
+    meshRangeBytes,
     environmentPortalBytes,
     configBytes: CONFIG_BUFFER_BYTES,
+    configBufferStride,
+    frameConfigBytes,
+    bvhBuildConfigBytes,
     counterBytes: COUNTER_BUFFER_BYTES,
     indirectDispatchBytes: INDIRECT_DISPATCH_ARGS_BYTES,
-    totalHotBufferBytes:
-      queueBytes * 2 +
-      hitBytes +
-      accumulationBytes +
-      pathVertexBytes +
-      sceneObjectBytes +
-      triangleBytes +
-      materialTableBytes +
-      bvhNodeBytes +
-      bvhLeafReferenceBytes +
-      emissiveTriangleMetadataBytes +
-      environmentPortalBytes +
-      CONFIG_BUFFER_BYTES +
-      COUNTER_BUFFER_BYTES +
-      INDIRECT_DISPATCH_ARGS_BYTES,
+    sceneStorageBufferBindingBytes,
+    totalHotBufferBytes,
+  });
+}
+
+export function estimateWavefrontPathTracingMemoryForConfig(config, limits = {}) {
+  return estimateWavefrontPathTracingMemory({
+    width: config.width,
+    height: config.height,
+    tileSize: config.tileSize,
+    samplesPerPixel: config.samplesPerPixel,
+    tilePixelCapacity: config.tilePixelCapacity,
+    maxDepth: config.maxDepth,
+    sceneObjectCapacity: config.sceneObjectCapacity,
+    triangleCapacity: config.triangleCapacity,
+    bvhNodeCapacity: config.bvhNodeCapacity,
+    bvhLeafSortCapacity: config.bvhLeafSortCapacity,
+    emissiveTriangleCapacity: config.emissiveTriangleCapacity,
+    environmentPortalCapacity: config.environmentPortalCapacity,
+    meshVertexCount: config.gpuMeshSource.vertices.count,
+    meshIndexCount: config.gpuMeshSource.indices.count,
+    meshRangeCount: config.gpuMeshSource.meshes.count,
+    bvhSortStageCount: config.bvhSortStages.length,
+    bvhBuildLevelCount: config.bvhBuildLevels.length,
+    denoise: config.denoise,
+    deferredPathResolve: config.deferredPathResolve,
+    minUniformBufferOffsetAlignment:
+      limits.minUniformBufferOffsetAlignment ??
+      WEBGPU_DEFAULT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT,
   });
 }
 
@@ -509,15 +637,25 @@ export function createWavefrontPathTracingComputeConfig(options = {}) {
     denoise: options.denoise !== false,
     frameIndex: readNonNegativeInteger("frameIndex", options.frameIndex, 0),
     memory: estimateWavefrontPathTracingMemory({
+      width,
+      height,
+      tileSize,
+      samplesPerPixel,
       tilePixelCapacity,
       maxDepth,
       sceneObjectCapacity,
       triangleCapacity,
-      materialCapacity: gpuMaterialSource.count,
       bvhNodeCapacity,
       bvhLeafSortCapacity,
       emissiveTriangleCapacity: emissiveTriangleIndices.capacity,
       environmentPortalCapacity,
+      meshVertexCount: gpuMeshSource.vertices.count,
+      meshIndexCount: gpuMeshSource.indices.count,
+      meshRangeCount: gpuMeshSource.meshes.count,
+      bvhSortStageCount: bvhSortStages.length,
+      bvhBuildLevelCount: bvhBuildLevels.length,
+      denoise: options.denoise !== false,
+      deferredPathResolve,
     }),
   });
 }

package/src/wavefront-frame-telemetry.js

@@ -297,7 +297,11 @@ export function createWavefrontFrameTelemetryResources({
       rayCountReadbackBuffer.unmap();
       rayReadbackMapped = false;
 
-      const bounceHistogram = Array.from({ length: Math.max(0, ...bounceIndices) + 1 }, () => 0);
+      let maximumBounceIndex = 0;
+      for (const bounceIndex of bounceIndices) {
+        maximumBounceIndex = Math.max(maximumBounceIndex, bounceIndex);
+      }
+      const bounceHistogram = Array.from({ length: maximumBounceIndex + 1 }, () => 0);
       let observedPrimaryRays = 0;
       let secondaryRays = 0;
       let totalPathSegments = 0;

package/src/wavefront-runtime-support.js

@@ -10,6 +10,37 @@ import {
   readPositiveInteger,
 } from "./wavefront-core.js";
 
+const WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE = 128 * 1024 * 1024;
+const WEBGPU_DEFAULT_MAX_BUFFER_SIZE = 256 * 1024 * 1024;
+
+function readRequestedDeviceLimit(source, name) {
+  const rawValue = source?.[name];
+  if (rawValue === undefined || rawValue === null) {
+    return 0;
+  }
+  const value = Number(rawValue);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative safe integer.`);
+  }
+  return value;
+}
+
+function assertAdapterSupportsRequiredLimit(adapter, name, requiredValue) {
+  const availableValue = Number(adapter?.limits?.[name]);
+  if (!Number.isFinite(availableValue)) {
+    throw new Error(
+      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, ` +
+        "but this adapter does not expose that limit."
+    );
+  }
+  if (availableValue < requiredValue) {
+    throw new Error(
+      `Wavefront scene buffers require ${name}>=${requiredValue} bytes, ` +
+        `but this adapter exposes ${availableValue} bytes.`
+    );
+  }
+}
+
 export function getGpuUsageConstants() {
   if (
     typeof GPUBufferUsage === "undefined" ||
@@ -123,8 +154,13 @@ export async function createRenderPipeline(device, descriptor) {
   return device.createRenderPipeline(descriptor);
 }
 
-export function createWavefrontDeviceDescriptor(adapter, options = {}) {
-  const requiredLimits = { ...(options.requiredLimits ?? {}) };
+export function createWavefrontDeviceDescriptor(adapter, options = {}, memory = null) {
+  const descriptor = { ...(options.deviceDescriptor ?? {}) };
+  const descriptorRequiredLimits = { ...(descriptor.requiredLimits ?? {}) };
+  const requiredLimits = {
+    ...descriptorRequiredLimits,
+    ...(options.requiredLimits ?? {}),
+  };
   const exposedStorageBufferLimit = Number(adapter?.limits?.maxStorageBuffersPerShaderStage);
   if (Number.isFinite(exposedStorageBufferLimit)) {
     if (exposedStorageBufferLimit < TRACE_STORAGE_BUFFER_BINDINGS) {
@@ -153,7 +189,40 @@ export function createWavefrontDeviceDescriptor(adapter, options = {}) {
     );
   }
 
-  const descriptor = { ...(options.deviceDescriptor ?? {}) };
+  const sceneStorageBufferBindingBytes = Number(
+    memory?.sceneStorageBufferBindingBytes ?? 0
+  );
+  const requestedStorageBufferBindingSize = Math.max(
+    readRequestedDeviceLimit(descriptorRequiredLimits, "maxStorageBufferBindingSize"),
+    readRequestedDeviceLimit(options.requiredLimits, "maxStorageBufferBindingSize"),
+    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE
+      ? sceneStorageBufferBindingBytes
+      : 0
+  );
+  if (requestedStorageBufferBindingSize > 0) {
+    assertAdapterSupportsRequiredLimit(
+      adapter,
+      "maxStorageBufferBindingSize",
+      requestedStorageBufferBindingSize
+    );
+    requiredLimits.maxStorageBufferBindingSize = requestedStorageBufferBindingSize;
+  }
+
+  const requestedMaxBufferSize = Math.max(
+    readRequestedDeviceLimit(descriptorRequiredLimits, "maxBufferSize"),
+    readRequestedDeviceLimit(options.requiredLimits, "maxBufferSize"),
+    sceneStorageBufferBindingBytes > WEBGPU_DEFAULT_MAX_BUFFER_SIZE
+      ? sceneStorageBufferBindingBytes
+      : 0,
+    requestedStorageBufferBindingSize > WEBGPU_DEFAULT_MAX_BUFFER_SIZE
+      ? requestedStorageBufferBindingSize
+      : 0
+  );
+  if (requestedMaxBufferSize > 0) {
+    assertAdapterSupportsRequiredLimit(adapter, "maxBufferSize", requestedMaxBufferSize);
+    requiredLimits.maxBufferSize = requestedMaxBufferSize;
+  }
+
   const requiredFeatures = Array.from(descriptor.requiredFeatures ?? []);
   const adapterFeatures = adapter?.features;
   const timestampQuerySupported =
@@ -217,6 +286,7 @@ export function createGpuAdapterParallelismDiagnostics(adapter, device) {
       maxComputeWorkgroupsPerDimension: readGpuLimit(adapter, device, "maxComputeWorkgroupsPerDimension"),
       maxStorageBuffersPerShaderStage: readGpuLimit(adapter, device, "maxStorageBuffersPerShaderStage"),
       maxStorageBufferBindingSize: readGpuLimit(adapter, device, "maxStorageBufferBindingSize"),
+      maxBufferSize: readGpuLimit(adapter, device, "maxBufferSize"),
     }),
     configuredWorkgroupSize: WORKGROUP_SIZE,
   });