@plasius/gpu-renderer 0.2.40 → 0.2.41

package/src/wavefront-frame-telemetry.js

@@ -0,0 +1,411 @@
+import { GPU_READBACK_COMPLETION_TIMEOUT_MS } from "./wavefront-core.js";
+import { createBuffer } from "./wavefront-gpu-resources.js";
+
+const TIMESTAMP_QUERY_COUNT = 2;
+const TIMESTAMP_BUFFER_BYTES = TIMESTAMP_QUERY_COUNT * BigUint64Array.BYTES_PER_ELEMENT;
+
+function hasGpuFeature(features, name) {
+  if (typeof features?.has === "function") {
+    return features.has(name);
+  }
+  if (features && typeof features[Symbol.iterator] === "function") {
+    return Array.from(features).includes(name);
+  }
+  return false;
+}
+
+function freezeRayCountTelemetry(values = {}) {
+  return Object.freeze({
+    status: values.status ?? "not-requested",
+    source: values.source ?? null,
+    expectedPrimaryRays: values.expectedPrimaryRays ?? null,
+    observedPrimaryRays: values.observedPrimaryRays ?? null,
+    secondaryRays: values.secondaryRays ?? null,
+    totalPathSegments: values.totalPathSegments ?? null,
+    bounceHistogram: Object.freeze([...(values.bounceHistogram ?? [])]),
+    capturedRayCounts: values.capturedRayCounts ?? 0,
+    expectedRayCounts: values.expectedRayCounts ?? 0,
+    reason: values.reason ?? null,
+  });
+}
+
+export function createWavefrontRayCountTelemetry(values = {}) {
+  return freezeRayCountTelemetry(values);
+}
+
+export function createWavefrontFrameTimingTelemetry(values = {}) {
+  return Object.freeze({
+    status: values.status ?? "not-requested",
+    source: values.source ?? null,
+    timestampQueryStatus: values.timestampQueryStatus ?? "not-recorded",
+    totalGpuTimeMs: values.totalGpuTimeMs ?? null,
+    totalRenderJobTimeMs: Math.max(0, Number(values.totalRenderJobTimeMs ?? 0)),
+    classificationTimeMs: values.classificationTimeMs ?? null,
+    compactionTimeMs: values.compactionTimeMs ?? null,
+    samplingTimeMs: values.samplingTimeMs ?? null,
+    reason: values.reason ?? null,
+  });
+}
+
+function safeErrorReason(error) {
+  return error instanceof Error && error.message
+    ? error.message
+    : "unknown-telemetry-readback-failure";
+}
+
+function timestampDurationMs(values) {
+  if (values.length < TIMESTAMP_QUERY_COUNT || values[1] < values[0]) {
+    return null;
+  }
+  const durationNanoseconds = values[1] - values[0];
+  const durationMs = Number(durationNanoseconds) / 1_000_000;
+  return Number.isFinite(durationMs) && durationMs >= 0 ? durationMs : null;
+}
+
+export function createWavefrontFrameTelemetryResources({
+  device,
+  constants,
+  maxRayCountRecords,
+}) {
+  const rayRecordCapacity = Math.max(1, Math.trunc(Number(maxRayCountRecords) || 1));
+  const rayBufferBytes = rayRecordCapacity * Uint32Array.BYTES_PER_ELEMENT;
+  const mapMode = constants.map;
+  if (!mapMode || typeof mapMode.READ !== "number") {
+    return Object.freeze({
+      available: false,
+      reason: "gpu-map-read-unavailable",
+      memoryBytes: 0,
+      beginFrame() {},
+      recordActiveRayCount() {},
+      decorateFirstPass(descriptor) {
+        return descriptor;
+      },
+      decorateFinalPass(descriptor) {
+        return descriptor;
+      },
+      async readFrame({ expectedPrimaryRays = 0, expectedRayCounts = 0 } = {}) {
+        return Object.freeze({
+          rayCounts: freezeRayCountTelemetry({
+            status: "unavailable",
+            expectedPrimaryRays,
+            expectedRayCounts,
+            reason: "gpu-map-read-unavailable",
+          }),
+          timestampQueryStatus: "unsupported",
+          totalGpuTimeMs: null,
+          reason: "gpu-map-read-unavailable",
+        });
+      },
+      destroy() {},
+    });
+  }
+
+  const rayCountBuffer = createBuffer(
+    device,
+    constants.buffer.COPY_DST | constants.buffer.COPY_SRC,
+    rayBufferBytes,
+    "plasius.wavefront.rayCounts"
+  );
+  const rayCountReadbackBuffer = createBuffer(
+    device,
+    constants.buffer.COPY_DST | constants.buffer.MAP_READ,
+    rayBufferBytes,
+    "plasius.wavefront.rayCounts.readback"
+  );
+
+  const timestampFeatureAvailable = hasGpuFeature(device?.features, "timestamp-query");
+  const timestampApiAvailable =
+    timestampFeatureAvailable &&
+    typeof device.createQuerySet === "function" &&
+    typeof constants.buffer.QUERY_RESOLVE === "number";
+  let timestampQuerySet = null;
+  let timestampResolveBuffer = null;
+  let timestampReadbackBuffer = null;
+  let timestampSetupReason = timestampFeatureAvailable
+    ? "timestamp-query-api-unavailable"
+    : "timestamp-query-unsupported";
+  if (timestampApiAvailable) {
+    try {
+      timestampQuerySet = device.createQuerySet({
+        label: "plasius.wavefront.timestamps",
+        type: "timestamp",
+        count: TIMESTAMP_QUERY_COUNT,
+      });
+      timestampResolveBuffer = createBuffer(
+        device,
+        constants.buffer.QUERY_RESOLVE | constants.buffer.COPY_SRC,
+        TIMESTAMP_BUFFER_BYTES,
+        "plasius.wavefront.timestamps.resolve"
+      );
+      timestampReadbackBuffer = createBuffer(
+        device,
+        constants.buffer.COPY_DST | constants.buffer.MAP_READ,
+        TIMESTAMP_BUFFER_BYTES,
+        "plasius.wavefront.timestamps.readback"
+      );
+      timestampSetupReason = null;
+    } catch (error) {
+      timestampQuerySet?.destroy?.();
+      timestampQuerySet = null;
+      timestampResolveBuffer?.destroy?.();
+      timestampResolveBuffer = null;
+      timestampReadbackBuffer?.destroy?.();
+      timestampReadbackBuffer = null;
+      timestampSetupReason = `timestamp-query-setup-failed:${safeErrorReason(error)}`;
+    }
+  }
+  const timestampUnavailableStatus = timestampSetupReason?.startsWith(
+    "timestamp-query-setup-failed:"
+  )
+    ? "failed"
+    : "unsupported";
+
+  let active = false;
+  let recordCount = 0;
+  let recordOverflow = false;
+  let bounceIndices = [];
+  let timestampStarted = false;
+  let timestampEnded = false;
+  let rayReadbackMapped = false;
+  let timestampReadbackMapped = false;
+
+  const memoryBytes =
+    rayBufferBytes * 2 +
+    (timestampQuerySet ? TIMESTAMP_BUFFER_BYTES * 2 : 0);
+
+  function beginFrame() {
+    active = true;
+    recordCount = 0;
+    recordOverflow = false;
+    bounceIndices = [];
+    timestampStarted = false;
+    timestampEnded = false;
+  }
+
+  function recordActiveRayCount(encoder, counterBuffer, bounceIndex) {
+    if (!active) {
+      return;
+    }
+    if (recordCount >= rayRecordCapacity) {
+      recordOverflow = true;
+      return;
+    }
+    encoder.copyBufferToBuffer(
+      counterBuffer,
+      0,
+      rayCountBuffer,
+      recordCount * Uint32Array.BYTES_PER_ELEMENT,
+      Uint32Array.BYTES_PER_ELEMENT
+    );
+    bounceIndices.push(Math.max(0, Math.trunc(Number(bounceIndex) || 0)));
+    recordCount += 1;
+  }
+
+  function decorateFirstPass(descriptor) {
+    if (!active || !timestampQuerySet || timestampStarted) {
+      return descriptor;
+    }
+    timestampStarted = true;
+    return {
+      ...descriptor,
+      timestampWrites: {
+        querySet: timestampQuerySet,
+        beginningOfPassWriteIndex: 0,
+      },
+    };
+  }
+
+  function decorateFinalPass(descriptor) {
+    if (!active || !timestampQuerySet || !timestampStarted || timestampEnded) {
+      return descriptor;
+    }
+    timestampEnded = true;
+    return {
+      ...descriptor,
+      timestampWrites: {
+        querySet: timestampQuerySet,
+        endOfPassWriteIndex: 1,
+      },
+    };
+  }
+
+  async function readFrame({
+    expectedPrimaryRays = 0,
+    expectedRayCounts = recordCount,
+    waitForSubmittedGpuWork,
+  } = {}) {
+    active = false;
+    if (recordOverflow || recordCount !== expectedRayCounts) {
+      return Object.freeze({
+        rayCounts: freezeRayCountTelemetry({
+          status: "failed",
+          expectedPrimaryRays,
+          capturedRayCounts: recordCount,
+          expectedRayCounts,
+          reason: recordOverflow
+            ? "ray-count-record-capacity-exceeded"
+            : `ray-count-record-mismatch:${recordCount}/${expectedRayCounts}`,
+        }),
+        timestampQueryStatus: timestampQuerySet ? "failed" : timestampUnavailableStatus,
+        totalGpuTimeMs: null,
+        reason: "ray-count-recording-incomplete",
+      });
+    }
+
+    const encoder = device.createCommandEncoder({
+      label: "plasius.wavefront.telemetry.readback",
+    });
+    const rayCopyBytes = Math.max(
+      Uint32Array.BYTES_PER_ELEMENT,
+      recordCount * Uint32Array.BYTES_PER_ELEMENT
+    );
+    encoder.copyBufferToBuffer(rayCountBuffer, 0, rayCountReadbackBuffer, 0, rayCopyBytes);
+    const canResolveTimestamps =
+      timestampQuerySet &&
+      timestampStarted &&
+      timestampEnded &&
+      typeof encoder.resolveQuerySet === "function";
+    if (canResolveTimestamps) {
+      encoder.resolveQuerySet(
+        timestampQuerySet,
+        0,
+        TIMESTAMP_QUERY_COUNT,
+        timestampResolveBuffer,
+        0
+      );
+      encoder.copyBufferToBuffer(
+        timestampResolveBuffer,
+        0,
+        timestampReadbackBuffer,
+        0,
+        TIMESTAMP_BUFFER_BYTES
+      );
+    }
+    device.queue.submit([encoder.finish()]);
+
+    try {
+      await waitForSubmittedGpuWork({
+        timeoutMs: GPU_READBACK_COMPLETION_TIMEOUT_MS,
+        allowTimeout: false,
+      });
+      await rayCountReadbackBuffer.mapAsync(mapMode.READ);
+      rayReadbackMapped = true;
+      const rayCopy = rayCountReadbackBuffer
+        .getMappedRange()
+        .slice(0, rayCopyBytes);
+      const rayCounts = new Uint32Array(rayCopy, 0, recordCount);
+      rayCountReadbackBuffer.unmap();
+      rayReadbackMapped = false;
+
+      const bounceHistogram = Array.from({ length: Math.max(0, ...bounceIndices) + 1 }, () => 0);
+      let observedPrimaryRays = 0;
+      let secondaryRays = 0;
+      let totalPathSegments = 0;
+      for (let index = 0; index < rayCounts.length; index += 1) {
+        const count = Number(rayCounts[index] ?? 0);
+        const bounceIndex = bounceIndices[index] ?? 0;
+        bounceHistogram[bounceIndex] = (bounceHistogram[bounceIndex] ?? 0) + count;
+        totalPathSegments += count;
+        if (bounceIndex === 0) {
+          observedPrimaryRays += count;
+        } else {
+          secondaryRays += count;
+        }
+      }
+      const primaryCountsMatch = observedPrimaryRays === expectedPrimaryRays;
+      const rayTelemetry = freezeRayCountTelemetry({
+        status: primaryCountsMatch ? "available" : "failed",
+        source: "gpu-active-queue-readback",
+        expectedPrimaryRays,
+        observedPrimaryRays,
+        secondaryRays: primaryCountsMatch ? secondaryRays : null,
+        totalPathSegments: primaryCountsMatch ? totalPathSegments : null,
+        bounceHistogram,
+        capturedRayCounts: recordCount,
+        expectedRayCounts,
+        reason: primaryCountsMatch
+          ? null
+          : `primary-ray-count-mismatch:${observedPrimaryRays}/${expectedPrimaryRays}`,
+      });
+
+      let timestampQueryStatus = timestampQuerySet ? "failed" : timestampUnavailableStatus;
+      let totalGpuTimeMs = null;
+      let timestampReason = timestampSetupReason;
+      if (canResolveTimestamps) {
+        try {
+          await timestampReadbackBuffer.mapAsync(mapMode.READ);
+          timestampReadbackMapped = true;
+          const timestampCopy = timestampReadbackBuffer
+            .getMappedRange()
+            .slice(0, TIMESTAMP_BUFFER_BYTES);
+          const timestamps = new BigUint64Array(timestampCopy);
+          timestampReadbackBuffer.unmap();
+          timestampReadbackMapped = false;
+          totalGpuTimeMs = timestampDurationMs(timestamps);
+          timestampQueryStatus = totalGpuTimeMs === null ? "failed" : "available";
+          timestampReason =
+            totalGpuTimeMs === null ? "timestamp-query-returned-invalid-range" : null;
+        } catch (error) {
+          if (timestampReadbackMapped) {
+            timestampReadbackBuffer.unmap();
+            timestampReadbackMapped = false;
+          }
+          timestampQueryStatus = "failed";
+          timestampReason = `timestamp-query-readback-failed:${safeErrorReason(error)}`;
+        }
+      } else if (timestampQuerySet) {
+        timestampReason = "timestamp-query-span-incomplete";
+      }
+
+      return Object.freeze({
+        rayCounts: rayTelemetry,
+        timestampQueryStatus,
+        totalGpuTimeMs,
+        reason: timestampReason,
+      });
+    } catch (error) {
+      if (rayReadbackMapped) {
+        rayCountReadbackBuffer.unmap();
+        rayReadbackMapped = false;
+      }
+      if (timestampReadbackMapped) {
+        timestampReadbackBuffer?.unmap();
+        timestampReadbackMapped = false;
+      }
+      const reason = safeErrorReason(error);
+      return Object.freeze({
+        rayCounts: freezeRayCountTelemetry({
+          status: "failed",
+          expectedPrimaryRays,
+          capturedRayCounts: recordCount,
+          expectedRayCounts,
+          reason: `ray-count-readback-failed:${reason}`,
+        }),
+        timestampQueryStatus: timestampQuerySet ? "failed" : timestampUnavailableStatus,
+        totalGpuTimeMs: null,
+        reason: `telemetry-readback-failed:${reason}`,
+      });
+    }
+  }
+
+  function destroy() {
+    active = false;
+    rayCountBuffer.destroy?.();
+    rayCountReadbackBuffer.destroy?.();
+    timestampQuerySet?.destroy?.();
+    timestampResolveBuffer?.destroy?.();
+    timestampReadbackBuffer?.destroy?.();
+  }
+
+  return Object.freeze({
+    available: true,
+    reason: null,
+    memoryBytes,
+    beginFrame,
+    recordActiveRayCount,
+    decorateFirstPass,
+    decorateFinalPass,
+    readFrame,
+    destroy,
+  });
+}

package/src/wavefront-pipelines.js

@@ -47,6 +47,18 @@ export function createWavefrontBindGroupLayouts(device, constants) {
       { binding: 30, visibility: constants.shader.COMPUTE, sampler: { type: "filtering" } },
       { binding: 31, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
       { binding: 32, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 33, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 34, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 35, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 36, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 37, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 38, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 39, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 40, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 41, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 42, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 43, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
+      { binding: 44, visibility: constants.shader.COMPUTE, texture: { sampleType: "float" } },
     ],
   });
   const acceleration = device.createBindGroupLayout({

package/src/wavefront-runtime-support.js

@@ -3,6 +3,7 @@ import {
   GPU_MAX_SUBMITTED_WORK_TIMEOUT_MS,
   GPU_READBACK_COMPLETION_TIMEOUT_MS,
   GPU_SUBMITTED_WORK_TIMEOUT_MS,
+  TRACE_SAMPLED_TEXTURE_BINDINGS,
   TRACE_STORAGE_BUFFER_BINDINGS,
   WORKGROUP_SIZE,
   readNonNegativeInteger,
@@ -50,11 +51,11 @@ export function resolveCanvas(canvasOrSelector, documentRef = globalThis.documen
 }
 
 async function getPipelineDiagnostics(shaderModule) {
-  if (typeof shaderModule?.compilationInfo !== "function") {
+  if (typeof shaderModule?.getCompilationInfo !== "function") {
     return "";
   }
   try {
-    const info = await shaderModule.compilationInfo();
+    const info = await shaderModule.getCompilationInfo();
     const messages = info.messages ?? [];
     if (messages.length === 0) {
       return "";
@@ -96,10 +97,10 @@ export async function createComputePipeline(device, shaderModule, layout, entryP
 }
 
 export async function assertShaderModuleCompiles(shaderModule, label) {
-  if (typeof shaderModule?.compilationInfo !== "function") {
+  if (typeof shaderModule?.getCompilationInfo !== "function") {
     return;
   }
-  const info = await shaderModule.compilationInfo();
+  const info = await shaderModule.getCompilationInfo();
   const messages = Array.isArray(info?.messages) ? info.messages : [];
   const errors = messages.filter((message) => message?.type === "error");
   if (errors.length <= 0) {
@@ -138,7 +139,39 @@ export function createWavefrontDeviceDescriptor(adapter, options = {}) {
     );
   }
 
+  const exposedSampledTextureLimit = Number(adapter?.limits?.maxSampledTexturesPerShaderStage);
+  if (Number.isFinite(exposedSampledTextureLimit)) {
+    if (exposedSampledTextureLimit < TRACE_SAMPLED_TEXTURE_BINDINGS) {
+      throw new Error(
+        `Wavefront material tracing requires maxSampledTexturesPerShaderStage>=${TRACE_SAMPLED_TEXTURE_BINDINGS}, ` +
+          `but this adapter exposes ${exposedSampledTextureLimit}.`
+      );
+    }
+    requiredLimits.maxSampledTexturesPerShaderStage = Math.max(
+      Number(requiredLimits.maxSampledTexturesPerShaderStage ?? 0),
+      TRACE_SAMPLED_TEXTURE_BINDINGS
+    );
+  }
+
   const descriptor = { ...(options.deviceDescriptor ?? {}) };
+  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;
+  if (
+    options.gpuTimestamps !== false &&
+    timestampQuerySupported &&
+    !requiredFeatures.includes("timestamp-query")
+  ) {
+    requiredFeatures.push("timestamp-query");
+  }
+  if (requiredFeatures.length > 0) {
+    descriptor.requiredFeatures = requiredFeatures;
+  }
   if (Object.keys(requiredLimits).length > 0) {
     descriptor.requiredLimits = {
       ...(descriptor.requiredLimits ?? {}),

package/src/wavefront-shader-bvh.js

@@ -113,36 +113,49 @@ fn prepareMeshTrianglesAndLeaves(@builtin(global_invocation_id) globalId: vec3<u
   let uv1 = select(vec2<f32>(0.0), vertex1.uv.xy, vertex1.uv.z > 0.5);
   let uv2 = select(vec2<f32>(0.0), vertex2.uv.xy, vertex2.uv.z > 0.5);
 
-  triangles[triangleIndex] = TriangleRecord(
-    triangleIndex,
-    mesh.meshId,
-    mesh.materialKind,
-    mesh.flags,
-    mesh.materialRefId,
-    mesh.mediumRefId,
-    mesh.materialSlot,
-    0u,
-    vec4<f32>(vertex0.position.xyz, 0.0),
-    vec4<f32>(vertex1.position.xyz, 0.0),
-    vec4<f32>(vertex2.position.xyz, 0.0),
-    vec4<f32>(n0, 0.0),
-    vec4<f32>(n1, 0.0),
-    vec4<f32>(n2, 0.0),
-    vec4<f32>(uv0, uv1),
-    vec4<f32>(uv2, 0.0, 0.0),
-    mesh.color,
-    mesh.emission,
-    mesh.material,
-    mesh.materialResponse,
-    mesh.materialExtension,
-    mesh.specularColor,
-    mesh.baseColorAtlas,
-    mesh.metallicRoughnessAtlas,
-    mesh.normalAtlas,
-    mesh.occlusionAtlas,
-    mesh.emissiveAtlas,
-    mesh.textureSettings
-  );
+  var preparedTriangle = TriangleRecord();
+  preparedTriangle.triangleId = triangleIndex;
+  preparedTriangle.meshId = mesh.meshId;
+  preparedTriangle.materialKind = mesh.materialKind;
+  preparedTriangle.flags = mesh.flags;
+  preparedTriangle.materialRefId = mesh.materialRefId;
+  preparedTriangle.mediumRefId = mesh.mediumRefId;
+  preparedTriangle.materialSlot = mesh.materialSlot;
+  preparedTriangle.v0 = vec4<f32>(vertex0.position.xyz, 0.0);
+  preparedTriangle.v1 = vec4<f32>(vertex1.position.xyz, 0.0);
+  preparedTriangle.v2 = vec4<f32>(vertex2.position.xyz, 0.0);
+  preparedTriangle.n0 = vec4<f32>(n0, 0.0);
+  preparedTriangle.n1 = vec4<f32>(n1, 0.0);
+  preparedTriangle.n2 = vec4<f32>(n2, 0.0);
+  preparedTriangle.uv0uv1 = vec4<f32>(uv0, uv1);
+  preparedTriangle.uv2Pad = vec4<f32>(uv2, 0.0, 0.0);
+  preparedTriangle.color = mesh.color;
+  preparedTriangle.emission = mesh.emission;
+  preparedTriangle.material = mesh.material;
+  preparedTriangle.materialResponse = mesh.materialResponse;
+  preparedTriangle.materialExtension = mesh.materialExtension;
+  preparedTriangle.specularColor = mesh.specularColor;
+  preparedTriangle.baseColorAtlas = mesh.baseColorAtlas;
+  preparedTriangle.metallicRoughnessAtlas = mesh.metallicRoughnessAtlas;
+  preparedTriangle.normalAtlas = mesh.normalAtlas;
+  preparedTriangle.occlusionAtlas = mesh.occlusionAtlas;
+  preparedTriangle.emissiveAtlas = mesh.emissiveAtlas;
+  preparedTriangle.textureSettings = mesh.textureSettings;
+  preparedTriangle.materialExtension2 = vec4<f32>(0.0, 0.0, 1.3, 0.0);
+  preparedTriangle.materialExtension3 = vec4<f32>(100.0, 400.0, 0.0, 0.0);
+  preparedTriangle.clearcoatAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.clearcoatRoughnessAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.clearcoatNormalAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.transmissionAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.thicknessAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.sheenColorAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.sheenRoughnessAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.specularAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.specularColorAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.iridescenceAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.iridescenceThicknessAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  preparedTriangle.anisotropyAtlas = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+  triangles[triangleIndex] = preparedTriangle;
 
   let leafBase = config.triangleCount - 1u;
   let nodeIndex = leafBase + triangleIndex;

package/src/wavefront-shader-kernels.js

@@ -224,36 +224,7 @@ fn intersectActiveQueue(@builtin(global_invocation_id) globalId: vec3<u32>) {
     vec4<f32>(1.0, 1.0, 1.0, 1.0)
   );
   var candidate = no_candidate();
-  var hitTriangle = TriangleRecord(
-    0u,
-    0u,
-    0u,
-    0u,
-    0u,
-    0u,
-    0u,
-    0u,
-    vec4<f32>(0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(0.0, 1.0, 0.0, 0.0),
-    vec4<f32>(0.0, 1.0, 0.0, 0.0),
-    vec4<f32>(0.0, 1.0, 0.0, 0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(0.0),
-    vec4<f32>(1.0, 0.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 0.0, 0.08),
-    vec4<f32>(0.08, 1.0, 0.0, 0.0),
-    vec4<f32>(1.0, 1.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 1.0, 1.0),
-    vec4<f32>(0.0, 0.0, 1.0, 1.0),
-    vec4<f32>(1.0, 1.0, 1.0, 0.0)
-  );
+  var hitTriangle = TriangleRecord();
 
   for (var objectIndex = 0u; objectIndex < config.sceneObjectCount; objectIndex = objectIndex + 1u) {
     let object = sceneObjects[objectIndex];