@plasius/gpu-renderer 0.2.42 → 0.2.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-renderer",
-  "version": "0.2.42",
+  "version": "0.2.44",
   "description": "Framework-agnostic WebGPU renderer runtime for Plasius projects.",
   "type": "module",
   "sideEffects": false,
@@ -27,7 +27,7 @@
   "scripts": {
     "build": "tsup",
     "demo": "python3 -m http.server --directory ..",
-    "typecheck": "node scripts/check-source-syntax.cjs",
+    "typecheck": "node scripts/check-source-syntax.cjs && tsc -p tsconfig.types.json && node scripts/verify-clean-type-consumer.cjs",
     "audit:eslint": "eslint . --max-warnings=0",
     "audit:deps": "npm ls --all --omit=optional --omit=peer > /dev/null 2>&1 || true",
     "audit:npm": "npm audit --audit-level=high --omit=dev",
@@ -53,14 +53,15 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@plasius/gpu-camera": "^0.1.18",
-    "@plasius/gpu-shared": "^1.0.14",
-    "@plasius/gpu-xr": "^0.1.17"
+    "@plasius/gpu-shared": "^1.1.1",
+    "@plasius/gpu-xr": "^0.1.17",
+    "@types/webxr": "^0.5.24"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "c8": "^11.0.0",
-    "eslint": "^10.6.0",
-    "globals": "^17.7.0",
+    "eslint": "^10.9.1",
+    "globals": "^17.11.0",
     "tsup": "^8.5.1",
     "typescript": "^7.0.2"
   },

package/src/feedback-diagnostics.js

@@ -0,0 +1,190 @@
+import {
+  FEEDBACK_GAME_DIAGNOSTICS_CONTRACT_VERSION,
+  feedbackGameDiagnosticSurfaceRegistrations,
+  parseFeedbackGameDiagnostics,
+} from "@plasius/gpu-shared/feedback-diagnostics";
+
+const inputKeys = Object.freeze([
+  "featureEnabled",
+  "capabilityGranted",
+  "consentConfirmed",
+  "surfaceId",
+  "renderer",
+  "backend",
+  "viewportWidth",
+  "viewportHeight",
+  "frameRate",
+  "frameTimeMs",
+  "featureIds",
+  "counters",
+  "errorCodes",
+]);
+
+export 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 < 1_440
+        ? "medium"
+        : "large";
+  const orientation = width > height ? "landscape" : "portrait";
+  return `${size}-${orientation}`;
+}
+
+export 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";
+}
+
+export 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";
+}
+
+export 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]
+      : undefined;
+
+  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 = Object.create(null);
+  for (const key of gateKeys) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    assertValid(
+      descriptor !== undefined &&
+        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((key) => !gateKeys.includes(key))) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    assertValid(
+      descriptor !== undefined &&
+        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.");
+  }
+}

package/src/index.d.ts

@@ -1,3 +1,60 @@
+/// <reference types="webxr" />
+
+import type {
+  FeedbackGameDiagnosticBackend,
+  FeedbackGameDiagnosticCounter,
+  FeedbackGameDiagnosticErrorCode,
+  FeedbackGameDiagnosticFeatureId,
+  FeedbackGameDiagnosticFrameRateBucket,
+  FeedbackGameDiagnosticFrameTimeBucket,
+  FeedbackGameDiagnostics,
+  FeedbackGameDiagnosticRenderer,
+  FeedbackGameDiagnosticSurfaceId,
+  FeedbackGameDiagnosticViewportBucket,
+} from "@plasius/gpu-shared/feedback-diagnostics";
+import type { XrStoreState } from "@plasius/gpu-xr";
+
+export interface CreateFeedbackGameDiagnosticSnapshotInput {
+  readonly featureEnabled: boolean;
+  readonly capabilityGranted: boolean;
+  readonly consentConfirmed: boolean;
+  readonly surfaceId: FeedbackGameDiagnosticSurfaceId;
+  readonly renderer: FeedbackGameDiagnosticRenderer;
+  readonly backend: FeedbackGameDiagnosticBackend;
+  /** CSS-pixel viewport width; it is bucketed synchronously and never returned. */
+  readonly viewportWidth: number | null;
+  /** CSS-pixel viewport height; it is bucketed synchronously and never returned. */
+  readonly viewportHeight: number | null;
+  /** Recent coarse FPS observation; it is bucketed synchronously and never returned. */
+  readonly frameRate: number | null;
+  /** Recent coarse frame-time observation; it is bucketed synchronously and never returned. */
+  readonly frameTimeMs: number | null;
+  readonly featureIds: readonly FeedbackGameDiagnosticFeatureId[];
+  readonly counters: readonly FeedbackGameDiagnosticCounter[];
+  readonly errorCodes: readonly FeedbackGameDiagnosticErrorCode[];
+}
+
+export function bucketFeedbackGameViewport(
+  width: unknown,
+  height: unknown,
+): FeedbackGameDiagnosticViewportBucket;
+
+export function bucketFeedbackGameFrameRate(
+  frameRate: unknown,
+): FeedbackGameDiagnosticFrameRateBucket;
+
+export function bucketFeedbackGameFrameTime(
+  frameTimeMs: unknown,
+): FeedbackGameDiagnosticFrameTimeBucket;
+
+export function createFeedbackGameDiagnosticSnapshot<
+  SurfaceId extends FeedbackGameDiagnosticSurfaceId,
+>(
+  input: CreateFeedbackGameDiagnosticSnapshotInput & {
+    readonly surfaceId: SurfaceId;
+  },
+): Extract<FeedbackGameDiagnostics, { readonly surfaceId: SurfaceId }> | null;
+
 export type RendererColor = string | [number, number, number, number?];
 export type AnimatedSceneVector3 = readonly [number, number, number] | readonly number[];
 export type AnimatedScenePropKind =
@@ -509,7 +566,6 @@ export interface WavefrontMeshInput {
   readonly occlusionTexture?: WavefrontTextureSampleInput | null;
   readonly emissiveTexture?: WavefrontTextureSampleInput | null;
   readonly medium?: WavefrontMediumInput | null;
-  readonly extensions?: Record<string, Record<string, unknown>>;
 }
 
 export interface WavefrontTriangleRecord {
@@ -960,12 +1016,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 +1051,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 +1344,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,
@@ -1570,13 +1650,12 @@ export interface GpuRenderer {
   setXrActive(active: boolean): void;
   getSnapshot(): RendererSnapshot;
   bindXrManager(
-    xrManager: {
-      subscribe: (listener: (state: { activeSession: XRSession | null }) => void) => () => void;
-      getState?: () => { activeSession: XRSession | null };
-      store?: { getSnapshot: () => { activeSession: XRSession | null } };
-    },
+    xrManager: RendererXrManager,
     bindOptions?: {
-      onSessionStart?: (session: XRSession, renderer: GpuRenderer) => void;
+      onSessionStart?: (
+        session: NonNullable<XrStoreState["activeSession"]>,
+        renderer: GpuRenderer
+      ) => void;
       onSessionEnd?: (renderer: GpuRenderer) => void;
     }
   ): () => void;
@@ -1612,15 +1691,22 @@ export function createRendererDebugHooks(
   options: RendererDebugHooksOptions
 ): Pick<RendererHooks, "onFrameStart" | "onFrameComplete">;
 
+export type RendererXrState = Pick<XrStoreState, "activeSession">;
+
+export interface RendererXrManager {
+  subscribe(listener: (state: RendererXrState) => void): () => void;
+  getState?(): RendererXrState;
+  store?: { getSnapshot(): RendererXrState };
+}
+
 export function bindRendererToXrManager(
   renderer: Pick<GpuRenderer, "setXrActive">,
-  xrManager: {
-    subscribe: (listener: (state: { activeSession: XRSession | null }) => void) => () => void;
-    getState?: () => { activeSession: XRSession | null };
-    store?: { getSnapshot: () => { activeSession: XRSession | null } };
-  },
+  xrManager: RendererXrManager,
   options?: {
-    onSessionStart?: (session: XRSession, renderer: Pick<GpuRenderer, "setXrActive">) => void;
+    onSessionStart?: (
+      session: NonNullable<XrStoreState["activeSession"]>,
+      renderer: Pick<GpuRenderer, "setXrActive">
+    ) => void;
     onSessionEnd?: (renderer: Pick<GpuRenderer, "setXrActive">) => void;
   }
 ): () => void;

package/src/index.js

@@ -4,6 +4,12 @@ export {
 export {
   createProfessionalAnimatedSceneRenderer,
 } from "./professional-animated-scene-renderer.js";
+export {
+  bucketFeedbackGameFrameRate,
+  bucketFeedbackGameFrameTime,
+  bucketFeedbackGameViewport,
+  createFeedbackGameDiagnosticSnapshot,
+} from "./feedback-diagnostics.js";
 export {
   createDefaultWavefrontSceneObjects,
   createWavefrontBvhBuildLevels,

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") {
@@ -222,8 +211,16 @@ export async function createWavefrontPathTracingComputeRenderer(options = {}) {
       width: config.width,
       height: config.height,
       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({
@@ -233,82 +230,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 +304,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"
   );