@plasius/gpu-renderer 0.2.42 → 0.2.43

package/CHANGELOG.md

@@ -23,6 +23,27 @@ All notable changes to this project will be documented in this file.
 - **Security**
   - (placeholder)
 
+## [0.2.43] - 2026-08-31
+
+- **Added**
+  - (placeholder)
+
+- **Changed**
+  - (placeholder)
+
+- **Fixed**
+  - Negotiated scene-derived `maxStorageBufferBindingSize` and, when required,
+    `maxBufferSize` before WebGPU device creation so large mesh/BVH scenes fail
+    early on unsupported adapters and render on adapters that expose sufficient
+    non-default limits.
+  - Corrected wavefront memory telemetry to match every persistent GPU buffer
+    descriptor exactly once, including placeholder records, combined BVH and
+    emissive metadata, mesh sources, and aligned frame/build config buffers,
+    while removing the nonexistent material-table allocation.
+
+- **Security**
+  - (placeholder)
+
 ## [0.2.42] - 2026-08-31
 
 - **Added**
@@ -1047,3 +1068,4 @@ All notable changes to this project will be documented in this file.
 [0.2.40]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.40
 [0.2.41]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.41
 [0.2.42]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.42
+[0.2.43]: https://github.com/Plasius-LTD/gpu-renderer/releases/tag/v0.2.43

package/README.md

@@ -429,6 +429,17 @@ without rebuilding scene buffers. `renderFrame(...)` also accepts an optional
 guarantees at least the minimum full-screen pass, and frame stats report both
 configured `samplesPerPixel` and actual `renderedSamplesPerPixel` so realtime
 callers can budget motion frames without overstating delivered quality.
+Before requesting a WebGPU device, the renderer derives the largest scene
+storage binding from the normalized scene, mesh, and BVH records. It requests
+the smallest sufficient `maxStorageBufferBindingSize` (and `maxBufferSize` only
+when the WebGPU default is also exceeded), preserves stricter caller limits,
+and rejects unsupported adapters before device creation. Default-sized scenes
+do not elevate either size limit. `config.memory` and snapshot memory telemetry
+describe the actual persistent GPU buffer descriptors: placeholder records,
+combined BVH/emissive storage, mesh source buffers, aligned frame/build uniform
+buffers, counters, and dispatch arguments are each counted exactly once;
+`materialTableBytes` is zero because material data is packed into mesh and
+triangle records rather than a standalone GPU buffer.
 For consumers that want to hand wavefront SPP adaptation to
 `@plasius/gpu-performance`, `createWavefrontAdaptiveSamplingLevels(...)` exposes
 a bounded low-to-high ladder of per-frame `samplesPerPixel`,

package/dist/index.cjs

@@ -4527,6 +4527,13 @@ function dispatchWavefrontGpuAccelerationBuild({
 }
 
 // src/wavefront-config.js
+var 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({
@@ -4703,6 +4710,18 @@ function resolveCamera(input, width, height) {
   });
 }
 function estimateWavefrontPathTracingMemory(options = {}) {
+  const width = readPositiveInteger2("width", options.width, DEFAULT_WIDTH);
+  const height = readPositiveInteger2("height", options.height, DEFAULT_HEIGHT);
+  const tileSize = readPositiveInteger2("tileSize", options.tileSize, DEFAULT_TILE_SIZE);
+  const samplesPerPixel = clamp2(
+    readPositiveInteger2(
+      "samplesPerPixel",
+      options.samplesPerPixel,
+      DEFAULT_SAMPLES_PER_PIXEL
+    ),
+    1,
+    MAX_SAMPLES_PER_PIXEL
+  );
   const tilePixelCapacity = readPositiveInteger2(
     "tilePixelCapacity",
     options.tilePixelCapacity,
@@ -4735,18 +4754,89 @@ function estimateWavefrontPathTracingMemory(options = {}) {
     options.environmentPortalCapacity,
     0
   );
-  const materialCapacity = readNonNegativeInteger2("materialCapacity", options.materialCapacity, 0);
+  readNonNegativeInteger2("materialCapacity", options.materialCapacity, 0);
+  const meshVertexCount = readNonNegativeInteger2(
+    "meshVertexCount",
+    options.meshVertexCount,
+    0
+  );
+  const meshIndexCount = readNonNegativeInteger2(
+    "meshIndexCount",
+    options.meshIndexCount,
+    0
+  );
+  const meshRangeCount = readNonNegativeInteger2(
+    "meshRangeCount",
+    options.meshRangeCount,
+    0
+  );
+  const bvhSortStageCount = readNonNegativeInteger2(
+    "bvhSortStageCount",
+    options.bvhSortStageCount,
+    0
+  );
+  const bvhBuildLevelCount = readNonNegativeInteger2(
+    "bvhBuildLevelCount",
+    options.bvhBuildLevelCount,
+    0
+  );
+  const minUniformBufferOffsetAlignment = readPositiveInteger2(
+    "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,
     queuePairBytes: queueBytes * 2,
@@ -4757,13 +4847,45 @@ 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
+  });
+}
+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
   });
 }
 function createWavefrontPathTracingComputeConfig(options = {}) {
@@ -4908,15 +5030,25 @@ function createWavefrontPathTracingComputeConfig(options = {}) {
     denoise: options.denoise !== false,
     frameIndex: readNonNegativeInteger2("frameIndex", options.frameIndex, 0),
     memory: estimateWavefrontPathTracingMemory({
+      width,
+      height,
+      tileSize,
+      samplesPerPixel,
       tilePixelCapacity,
       maxDepth,
       sceneObjectCapacity,
       triangleCapacity,
-      materialCapacity: gpuMaterialSource.count,
       bvhNodeCapacity,
       bvhLeafSortCapacity,
       emissiveTriangleCapacity: emissiveTriangleIndices.capacity,
-      environmentPortalCapacity
+      environmentPortalCapacity,
+      meshVertexCount: gpuMeshSource.vertices.count,
+      meshIndexCount: gpuMeshSource.indices.count,
+      meshRangeCount: gpuMeshSource.meshes.count,
+      bvhSortStageCount: bvhSortStages.length,
+      bvhBuildLevelCount: bvhBuildLevels.length,
+      denoise: options.denoise !== false,
+      deferredPathResolve
     })
   });
 }
@@ -5761,6 +5893,32 @@ function createWavefrontPresentBindGroup({
 }
 
 // src/wavefront-runtime-support.js
+var WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE = 128 * 1024 * 1024;
+var WEBGPU_DEFAULT_MAX_BUFFER_SIZE = 256 * 1024 * 1024;
+function readRequestedDeviceLimit(source, name) {
+  const rawValue = source?.[name];
+  if (rawValue === void 0 || 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.`
+    );
+  }
+}
 function getGpuUsageConstants() {
   if (typeof GPUBufferUsage === "undefined" || typeof GPUTextureUsage === "undefined" || typeof GPUShaderStage === "undefined") {
     throw new Error("WebGPU runtime unavailable. Required GPU constants are missing.");
@@ -5858,8 +6016,13 @@ async function createRenderPipeline(device, descriptor) {
   }
   return device.createRenderPipeline(descriptor);
 }
-function createWavefrontDeviceDescriptor(adapter, options = {}) {
-  const requiredLimits = { ...options.requiredLimits ?? {} };
+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) {
@@ -5884,7 +6047,32 @@ function createWavefrontDeviceDescriptor(adapter, options = {}) {
       TRACE_SAMPLED_TEXTURE_BINDINGS
     );
   }
-  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 = typeof adapterFeatures?.has === "function" ? adapterFeatures.has("timestamp-query") : adapterFeatures && typeof adapterFeatures[Symbol.iterator] === "function" ? Array.from(adapterFeatures).includes("timestamp-query") : false;
@@ -5935,7 +6123,8 @@ function createGpuAdapterParallelismDiagnostics(adapter, device) {
       maxComputeWorkgroupSizeZ: readGpuLimit(adapter, device, "maxComputeWorkgroupSizeZ"),
       maxComputeWorkgroupsPerDimension: readGpuLimit(adapter, device, "maxComputeWorkgroupsPerDimension"),
       maxStorageBuffersPerShaderStage: readGpuLimit(adapter, device, "maxStorageBuffersPerShaderStage"),
-      maxStorageBufferBindingSize: readGpuLimit(adapter, device, "maxStorageBufferBindingSize")
+      maxStorageBufferBindingSize: readGpuLimit(adapter, device, "maxStorageBufferBindingSize"),
+      maxBufferSize: readGpuLimit(adapter, device, "maxBufferSize")
     }),
     configuredWorkgroupSize: WORKGROUP_SIZE
   });
@@ -11241,7 +11430,9 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
   if (!adapter) {
     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") {
@@ -11259,6 +11450,10 @@ 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({
@@ -11267,79 +11462,72 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
     alphaMode: options.alpha === true ? "premultiplied" : "opaque"
   });
   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,
@@ -11348,26 +11536,25 @@ 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"
   );
   let packedScene = packWavefrontSceneObjects(config.sceneObjects, config.sceneObjectCapacity);