@plasius/gpu-renderer 0.2.56 → 0.2.58

package/src/wavefront-mesh-sources.js

@@ -159,7 +159,7 @@ function chooseSplitAxis(triangles) {
   return extent[1] >= extent[2] ? 1 : 2;
 }
 
-function buildBvh(triangles, maxLeafTriangles = 4) {
+export function buildWavefrontBoundsBvh(triangles, maxLeafTriangles = 4) {
   if (triangles.length === 0) {
     return Object.freeze({ nodes: Object.freeze([]), triangles: Object.freeze([]) });
   }
@@ -217,7 +217,7 @@ export function createWavefrontMeshAcceleration(meshes = [], gpuMaterialSource =
   const source = Array.isArray(meshes) ? meshes : [meshes];
   const resolvedMaterialSource = gpuMaterialSource ?? createWavefrontGpuMaterialSource(source);
   const triangles = createMeshTriangleRecords(source, resolvedMaterialSource);
-  return buildBvh(triangles);
+  return buildWavefrontBoundsBvh(triangles);
 }
 
 export function estimateMeshSourceShape(meshes) {

package/src/wavefront-pipelines.js

@@ -3,10 +3,10 @@ import {
   createComputePipeline,
   createRenderPipeline,
 } from "./wavefront-runtime-support.js";
-import { PRESENT_WGSL, WAVEFRONT_COMPUTE_WGSL } from "./wavefront-shaders.js";
+import { PRESENT_WGSL, createWavefrontPathTracingComputeShaderSource } from "./wavefront-shaders.js";
 import { CONFIG_BUFFER_BYTES } from "./wavefront-core.js";
 
-export function createWavefrontBindGroupLayouts(device, constants) {
+export function createWavefrontBindGroupLayouts(device, constants, instanced = false) {
   const trace = device.createBindGroupLayout({
     label: "plasius.wavefront.traceBindGroupLayout",
     entries: [
@@ -59,6 +59,7 @@ export function createWavefrontBindGroupLayouts(device, constants) {
       { 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" } },
+      ...(instanced ? [{binding:47, visibility:constants.shader.COMPUTE, texture:{sampleType:"uint"}}] : []),
     ],
   });
   const acceleration = device.createBindGroupLayout({
@@ -258,12 +259,12 @@ export async function createWavefrontPresentPipeline(device, presentBindGroupLay
   });
 }
 
-export async function createWavefrontPipelineResources({ device, constants, format }) {
-  const bindGroupLayouts = createWavefrontBindGroupLayouts(device, constants);
+export async function createWavefrontPipelineResources({ device, constants, format, instanced = false }) {
+  const bindGroupLayouts = createWavefrontBindGroupLayouts(device, constants, instanced);
   const pipelineLayouts = createWavefrontPipelineLayouts(device, bindGroupLayouts);
   const computeShader = device.createShaderModule({
     label: "plasius.wavefront.computeShader",
-    code: WAVEFRONT_COMPUTE_WGSL,
+    code: createWavefrontPathTracingComputeShaderSource({instanced}),
   });
   await assertShaderModuleCompiles(computeShader, "plasius.wavefront.computeShader");
 

package/src/wavefront-runtime-support.js

@@ -161,31 +161,33 @@ export function createWavefrontDeviceDescriptor(adapter, options = {}, memory =
     ...descriptorRequiredLimits,
     ...(options.requiredLimits ?? {}),
   };
+  const traceStorageBindings = TRACE_STORAGE_BUFFER_BINDINGS;
+  const traceTextureBindings = TRACE_SAMPLED_TEXTURE_BINDINGS + (options.instances !== undefined ? 1 : 0);
   const exposedStorageBufferLimit = Number(adapter?.limits?.maxStorageBuffersPerShaderStage);
   if (Number.isFinite(exposedStorageBufferLimit)) {
-    if (exposedStorageBufferLimit < TRACE_STORAGE_BUFFER_BINDINGS) {
+    if (exposedStorageBufferLimit < traceStorageBindings) {
       throw new Error(
-        `Wavefront mesh tracing requires maxStorageBuffersPerShaderStage>=${TRACE_STORAGE_BUFFER_BINDINGS}, ` +
+        `Wavefront mesh tracing requires maxStorageBuffersPerShaderStage>=${traceStorageBindings}, ` +
           `but this adapter exposes ${exposedStorageBufferLimit}.`
       );
     }
     requiredLimits.maxStorageBuffersPerShaderStage = Math.max(
       Number(requiredLimits.maxStorageBuffersPerShaderStage ?? 0),
-      TRACE_STORAGE_BUFFER_BINDINGS
+      traceStorageBindings
     );
   }
 
   const exposedSampledTextureLimit = Number(adapter?.limits?.maxSampledTexturesPerShaderStage);
   if (Number.isFinite(exposedSampledTextureLimit)) {
-    if (exposedSampledTextureLimit < TRACE_SAMPLED_TEXTURE_BINDINGS) {
+    if (exposedSampledTextureLimit < traceTextureBindings) {
       throw new Error(
-        `Wavefront material tracing requires maxSampledTexturesPerShaderStage>=${TRACE_SAMPLED_TEXTURE_BINDINGS}, ` +
+        `Wavefront material tracing requires maxSampledTexturesPerShaderStage>=${traceTextureBindings}, ` +
           `but this adapter exposes ${exposedSampledTextureLimit}.`
       );
     }
     requiredLimits.maxSampledTexturesPerShaderStage = Math.max(
       Number(requiredLimits.maxSampledTexturesPerShaderStage ?? 0),
-      TRACE_SAMPLED_TEXTURE_BINDINGS
+      traceTextureBindings
     );
   }
 

package/src/wavefront-shader-bvh.js

@@ -459,6 +459,7 @@ fn no_candidate() -> Candidate {
     1u,
     0xffffffffu,
     0xffffffffu,
+    0xffffffffu,
     0u,
     0u
   );
@@ -485,6 +486,7 @@ fn surface_candidate(
     uv,
     frontFace,
     triangleIndex,
+    0xffffffffu,
     primitiveId,
     materialRefId,
     mediumRefId
@@ -546,7 +548,7 @@ fn intersect_triangle(ray: RayRecord, triangle: TriangleRecord, triangleIndex: u
   );
 }
 
-fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
+fn intersect_geometry_bvh(ray: RayRecord, initialNearest: f32, root: u32) -> Candidate {
   var nearest = initialNearest;
   var best = no_candidate();
   if (config.bvhNodeCount == 0u || config.triangleCount == 0u) {
@@ -555,7 +557,7 @@ fn intersect_bvh(ray: RayRecord, initialNearest: f32) -> Candidate {
 
   var stack = array<u32, 64>();
   var stackSize = 1u;
-  stack[0] = 0u;
+  stack[0] = root;
 
   loop {
     if (stackSize == 0u) {

package/src/wavefront-shader-kernels.js

@@ -245,7 +245,7 @@ fn intersectActiveQueue(@builtin(global_invocation_id) globalId: vec3<u32>) {
   if (meshCandidate.hit == 1u && meshCandidate.distance < nearest) {
     nearest = meshCandidate.distance;
     candidate = meshCandidate;
-    hitTriangle = triangles[meshCandidate.triangleIndex];
+    hitTriangle = triangle_for_candidate(meshCandidate);
   }
 
   if (candidate.hit == 0u) {

package/src/wavefront-shader-layout.js

@@ -283,6 +283,7 @@ struct Candidate {
   uv: vec2<f32>,
   frontFace: u32,
   triangleIndex: u32,
+  instanceIndex: u32,
   primitiveId: u32,
   materialRefId: u32,
   mediumRefId: u32,

package/src/wavefront-shaders.js

@@ -1,3 +1,4 @@
+import { WAVEFRONT_INSTANCE_SHADER_WGSL, WAVEFRONT_UNINSTANCED_SHADER_WGSL } from './wavefront-instance-shader.js';
 import { WAVEFRONT_COMPUTE_WORKGROUP_SIZE } from "./wavefront-workgroup.js";
 import { WAVEFRONT_SHADER_BVH_WGSL } from "./wavefront-shader-bvh.js";
 import { WAVEFRONT_SHADER_KERNELS_WGSL } from "./wavefront-shader-kernels.js";
@@ -22,6 +23,7 @@ export const WAVEFRONT_COMPUTE_WGSL = [
   WAVEFRONT_SHADER_MATERIALS_WGSL,
   WAVEFRONT_SHADER_LIGHTING_WGSL,
   WAVEFRONT_SHADER_BVH_WGSL,
+  WAVEFRONT_UNINSTANCED_SHADER_WGSL,
   WAVEFRONT_SHADER_KERNELS_WGSL,
 ].join("\n");
 
@@ -34,5 +36,7 @@ export function createWavefrontPathTracingComputeShaderSource(options = {}) {
   if (workgroupSize !== WAVEFRONT_COMPUTE_WORKGROUP_SIZE) {
     throw new Error(`wavefront mesh compute currently requires workgroupSize=${WAVEFRONT_COMPUTE_WORKGROUP_SIZE}`);
   }
-  return WAVEFRONT_COMPUTE_WGSL;
+  return options.instanced === true
+    ? WAVEFRONT_COMPUTE_WGSL.replace(WAVEFRONT_UNINSTANCED_SHADER_WGSL, WAVEFRONT_INSTANCE_SHADER_WGSL)
+    : WAVEFRONT_COMPUTE_WGSL;
 }

package/src/wavefront-upload.js

@@ -0,0 +1,12 @@
+import { waitForSubmittedGpuWork } from './wavefront-gpu-synchronization.js';
+
+// Large writeBuffer calls need temporary driver staging storage in addition to
+// the destination. Complete each bounded chunk before requesting the next one.
+export async function uploadWavefrontBuffer(device, buffer, data, {chunkBytes=8*1024*1024}={}) {
+  if(!Number.isSafeInteger(chunkBytes)||chunkBytes<4||chunkBytes%4!==0) throw new Error('GPU upload chunk size must be a positive multiple of four.');
+  if(data.byteLength<=chunkBytes){device.queue.writeBuffer(buffer,0,data);return;}
+  for(let offset=0;offset<data.byteLength;offset+=chunkBytes){
+    device.queue.writeBuffer(buffer,offset,data,offset,Math.min(chunkBytes,data.byteLength-offset));
+    await waitForSubmittedGpuWork(device,{timeoutMs:10000,maxWaitMs:10000,allowTimeout:false});
+  }
+}