@plasius/gpu-renderer 0.2.42 → 0.2.44

package/dist/index.js

@@ -2205,6 +2205,144 @@ async function createProfessionalAnimatedSceneRenderer(options = {}) {
   };
 }
 
+// src/feedback-diagnostics.js
+import {
+  FEEDBACK_GAME_DIAGNOSTICS_CONTRACT_VERSION,
+  feedbackGameDiagnosticSurfaceRegistrations,
+  parseFeedbackGameDiagnostics
+} from "@plasius/gpu-shared/feedback-diagnostics";
+var inputKeys = Object.freeze([
+  "featureEnabled",
+  "capabilityGranted",
+  "consentConfirmed",
+  "surfaceId",
+  "renderer",
+  "backend",
+  "viewportWidth",
+  "viewportHeight",
+  "frameRate",
+  "frameTimeMs",
+  "featureIds",
+  "counters",
+  "errorCodes"
+]);
+function bucketFeedbackGameViewport(width, height) {
+  if (typeof width !== "number" || typeof height !== "number" || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return "unknown";
+  }
+  const shorterEdge = Math.min(width, height);
+  const longerEdge = Math.max(width, height);
+  const size = shorterEdge < 600 ? "small" : shorterEdge < 900 || longerEdge < 1440 ? "medium" : "large";
+  const orientation = width > height ? "landscape" : "portrait";
+  return `${size}-${orientation}`;
+}
+function bucketFeedbackGameFrameRate(frameRate) {
+  if (typeof frameRate !== "number" || !Number.isFinite(frameRate) || frameRate < 0) {
+    return "unknown";
+  }
+  if (frameRate < 15) {
+    return "under-15";
+  }
+  if (frameRate < 30) {
+    return "15-29";
+  }
+  if (frameRate < 60) {
+    return "30-59";
+  }
+  return "60-plus";
+}
+function bucketFeedbackGameFrameTime(frameTimeMs) {
+  if (typeof frameTimeMs !== "number" || !Number.isFinite(frameTimeMs) || frameTimeMs < 0) {
+    return "unknown";
+  }
+  if (frameTimeMs < 17) {
+    return "under-17ms";
+  }
+  if (frameTimeMs < 34) {
+    return "17-33ms";
+  }
+  if (frameTimeMs < 67) {
+    return "34-66ms";
+  }
+  return "over-66ms";
+}
+function createFeedbackGameDiagnosticSnapshot(input) {
+  try {
+    return createFeedbackGameDiagnosticSnapshotInternal(input);
+  } catch {
+    throw new TypeError("Invalid privacy-safe renderer diagnostics input.");
+  }
+}
+function createFeedbackGameDiagnosticSnapshotInternal(input) {
+  const snapshot = snapshotInputIfEnabled(input);
+  if (snapshot === null) {
+    return null;
+  }
+  const registration = typeof snapshot.surfaceId === "string" && Object.hasOwn(
+    feedbackGameDiagnosticSurfaceRegistrations,
+    snapshot.surfaceId
+  ) ? feedbackGameDiagnosticSurfaceRegistrations[snapshot.surfaceId] : void 0;
+  return parseFeedbackGameDiagnostics({
+    type: "feedback-game-diagnostics",
+    version: FEEDBACK_GAME_DIAGNOSTICS_CONTRACT_VERSION,
+    surfaceId: snapshot.surfaceId,
+    consentConfirmed: true,
+    provenanceContractId: registration?.provenanceContractId,
+    renderer: snapshot.renderer,
+    backend: snapshot.backend,
+    viewportBucket: bucketFeedbackGameViewport(
+      snapshot.viewportWidth,
+      snapshot.viewportHeight
+    ),
+    frameRateBucket: bucketFeedbackGameFrameRate(snapshot.frameRate),
+    frameTimeBucket: bucketFeedbackGameFrameTime(snapshot.frameTimeMs),
+    featureIds: snapshot.featureIds,
+    counters: snapshot.counters,
+    errorCodes: snapshot.errorCodes
+  });
+}
+function snapshotInputIfEnabled(input) {
+  assertValid(
+    input !== null && typeof input === "object" && !Array.isArray(input) && (Object.getPrototypeOf(input) === Object.prototype || Object.getPrototypeOf(input) === null)
+  );
+  const gateKeys = [
+    "featureEnabled",
+    "capabilityGranted",
+    "consentConfirmed"
+  ];
+  const snapshot = /* @__PURE__ */ Object.create(null);
+  for (const key of gateKeys) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    assertValid(
+      descriptor !== void 0 && descriptor.enumerable === true && Object.hasOwn(descriptor, "value") && typeof descriptor.value === "boolean"
+    );
+    snapshot[key] = descriptor.value;
+  }
+  const { featureEnabled, capabilityGranted, consentConfirmed } = snapshot;
+  if (!featureEnabled || !capabilityGranted || !consentConfirmed) {
+    return null;
+  }
+  const actualKeys = Reflect.ownKeys(input);
+  assertValid(
+    actualKeys.length === inputKeys.length && inputKeys.every((key) => actualKeys.includes(key)) && actualKeys.every(
+      (key) => typeof key === "string" && inputKeys.includes(key)
+    )
+  );
+  for (const key of inputKeys.filter((key2) => !gateKeys.includes(key2))) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    assertValid(
+      descriptor !== void 0 && descriptor.enumerable === true && Object.hasOwn(descriptor, "value")
+    );
+    snapshot[key] = descriptor.value;
+  }
+  return Object.freeze(snapshot);
+}
+function assertValid(condition) {
+  if (!condition) {
+    throw new TypeError("Invalid privacy-safe renderer diagnostics input.");
+  }
+}
+
 // src/wavefront-frame-runtime.js
 function createGpuParallelismCounters() {
   return {
@@ -4438,6 +4576,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({
@@ -4614,6 +4759,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,
@@ -4646,18 +4803,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,
@@ -4668,13 +4896,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 = {}) {
@@ -4819,15 +5079,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
     })
   });
 }
@@ -4918,7 +5188,13 @@ function clampTileSizeForDevice(config, device) {
   }
   const maxPixelsByRay = Math.floor(limit / RAY_RECORD_BYTES);
   const maxPixelsByHit = Math.floor(limit / HIT_RECORD_BYTES);
-  const maxPixels = Math.max(256, Math.min(maxPixelsByRay, maxPixelsByHit));
+  const maxPixelsByPathVertex = Math.floor(
+    limit / ((config.maxDepth + 1) * PATH_VERTEX_RECORD_BYTES)
+  );
+  const maxPixels = Math.max(
+    256,
+    Math.min(maxPixelsByRay, maxPixelsByHit, maxPixelsByPathVertex)
+  );
   if (config.tilePixelCapacity <= maxPixels) {
     return config.tileSize;
   }
@@ -5672,6 +5948,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.");
@@ -5769,8 +6071,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) {
@@ -5795,7 +6102,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;
@@ -5846,7 +6178,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
   });
@@ -11152,7 +11485,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") {
@@ -11167,9 +11502,17 @@ async function createWavefrontPathTracingComputeRenderer(options = {}) {
       canvas,
       width: config.width,
       height: config.height,
-      tileSize: safeTileSize
+      tileSize: safeTileSize,
+      tilePixelCapacity: Math.min(
+        config.tilePixelCapacity,
+        safeTileSize * safeTileSize
+      )
     });
   }
+  config = Object.freeze({
+    ...config,
+    memory: estimateWavefrontPathTracingMemoryForConfig(config, device.limits)
+  });
   canvas.width = config.width;
   canvas.height = config.height;
   context.configure({
@@ -11178,79 +11521,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,
@@ -11259,26 +11595,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);
@@ -12988,8 +13323,12 @@ export {
   applyMediumTransmittance,
   beerLambertTransmittance,
   bindRendererToXrManager,
+  bucketFeedbackGameFrameRate,
+  bucketFeedbackGameFrameTime,
+  bucketFeedbackGameViewport,
   createAnimatedSceneRenderer,
   createDefaultWavefrontSceneObjects,
+  createFeedbackGameDiagnosticSnapshot,
   createGpuRenderer,
   createMediumStack,
   createProfessionalAnimatedSceneRenderer,