@tinypoly/gpu-renderer 0.2.5 → 0.3.0

package/dist/wgsl/texture.wgsl.d.ts

@@ -7,5 +7,5 @@
  * renderer already draws many jittered samples through every pixel, which averages that detail properly instead of
  * approximating it. Levels would buy memory locality, not correctness, so they can wait.
  */
-export declare const TEXTURE_WGSL = "\nconst TEXTURE_FLOAT: u32 = 1u;\nconst TEXTURE_SRGB: u32 = 2u;\nconst TEXTURE_NEAREST: u32 = 4u;\nconst TEXTURE_FLIP_Y: u32 = 8u;\n\n// Three's own wrap constants. Anything else clamps, as it does in the CPU renderer.\nconst WRAP_REPEAT: u32 = 1000u;\nconst WRAP_MIRROR: u32 = 1002u;\n\n/** Brings a texel index inside the texture the way the wrap mode says to. */\nfn wrapIndex(index: i32, size: i32, mode: u32) -> i32 {\n  if (mode == WRAP_REPEAT) {\n    return ((index % size) + size) % size;\n  }\n\n  if (mode == WRAP_MIRROR) {\n    let period = size * 2;\n    let folded = ((index % period) + period) % period;\n\n    return select(period - 1 - folded, folded, folded < size);\n  }\n\n  return clamp(index, 0, size - 1);\n}\n\n/** One texel, in linear light. Alpha is never encoded, as in Three. */\nfn readTexel(info: TextureInfo, x: i32, y: i32) -> vec4<f32> {\n  let index = u32(y) * info.size.x + u32(x);\n\n  if ((info.flags & TEXTURE_FLOAT) != 0u) {\n    let at = info.offset + index * 4u;\n\n    return vec4<f32>(\n      bitcast<f32>(textures[at]),\n      bitcast<f32>(textures[at + 1u]),\n      bitcast<f32>(textures[at + 2u]),\n      bitcast<f32>(textures[at + 3u]));\n  }\n\n  let word = textures[info.offset + index];\n\n  // The decode is a table of the 256 codes rather than a power per channel and per texel: the same values, read.\n  if ((info.flags & TEXTURE_SRGB) != 0u) {\n    return vec4<f32>(\n      bitcast<f32>(textures[SRGB_TABLE + (word & 0xffu)]),\n      bitcast<f32>(textures[SRGB_TABLE + ((word >> 8u) & 0xffu)]),\n      bitcast<f32>(textures[SRGB_TABLE + ((word >> 16u) & 0xffu)]),\n      f32((word >> 24u) & 0xffu) / 255.0);\n  }\n\n  return vec4<f32>(\n    f32(word & 0xffu),\n    f32((word >> 8u) & 0xffu),\n    f32((word >> 16u) & 0xffu),\n    f32((word >> 24u) & 0xffu)) / 255.0;\n}\n\n/** One texture of the table, sampled with its own transform, wrap modes and filter. */\nfn sampleTextureAt(index: u32, uv: vec2<f32>) -> vec4<f32> {\n  let info = textureInfo(index);\n  // The affine transform Three keeps on the texture, one row at a time.\n  let transformed = vec2<f32>(\n    dot(info.rowU.xyz, vec3<f32>(uv, 1.0)),\n    dot(info.rowV.xyz, vec3<f32>(uv, 1.0)));\n\n  return sampleTextureInfo(info, transformed);\n}\n\n/**\n * A texture read the way GLSL's texture2D reads it: at the coordinates given, with no transform. Three applies a\n * texture's matrix in its own materials' shaders, so a shader of the scene's, an environment lookup and a light's\n * projected map do not get it.\n */\nfn sampleTextureRaw(index: u32, uv: vec2<f32>) -> vec4<f32> {\n  return sampleTextureInfo(textureInfo(index), uv);\n}\n\n/** Three's equirectUv: longitude across, and latitude up from the bottom of the image, as GL reads it. */\nfn equirectUv(direction: vec3<f32>) -> vec2<f32> {\n  let d = normalize(direction);\n\n  return vec2<f32>(atan2(d.z, d.x) / (2.0 * PI) + 0.5, asin(clamp(d.y, -1.0, 1.0)) / PI + 0.5);\n}\n\n/** An environment map of the scene's: an equirectangular image, or a cube map the snapshot already unwrapped into one. */\nfn sampleEquirect(index: u32, direction: vec3<f32>) -> vec4<f32> {\n  return sampleTextureRaw(index, equirectUv(direction));\n}\n\nfn sampleTextureInfo(info: TextureInfo, transformed: vec2<f32>) -> vec4<f32> {\n  if (!all(transformed == transformed) || info.size.x == 0u || info.size.y == 0u) {\n    return vec4<f32>(0.0);\n  }\n\n  let flipped = select(transformed.y, 1.0 - transformed.y, (info.flags & TEXTURE_FLIP_Y) != 0u);\n  let size = vec2<i32>(info.size);\n  // The half texel offset that puts a sample in the middle of a texel, as on a graphics pipeline.\n  let centred = vec2<f32>(transformed.x, flipped) * vec2<f32>(info.size) - 0.5;\n\n  if ((info.flags & TEXTURE_NEAREST) != 0u) {\n    let at = vec2<i32>(floor(centred + 0.5));\n\n    return readTexel(info, wrapIndex(at.x, size.x, info.wrapS), wrapIndex(at.y, size.y, info.wrapT));\n  }\n\n  let low = floor(centred);\n  let fraction = centred - low;\n  let base = vec2<i32>(low);\n  let x0 = wrapIndex(base.x, size.x, info.wrapS);\n  let x1 = wrapIndex(base.x + 1, size.x, info.wrapS);\n  let y0 = wrapIndex(base.y, size.y, info.wrapT);\n  let y1 = wrapIndex(base.y + 1, size.y, info.wrapT);\n\n  // The four corners are blended in linear light, which is why the decode happens per texel above.\n  return mix(\n    mix(readTexel(info, x0, y0), readTexel(info, x1, y0), fraction.x),\n    mix(readTexel(info, x0, y1), readTexel(info, x1, y1), fraction.x),\n    fraction.y);\n}\n";
+export declare const TEXTURE_WGSL = "\nconst TEXTURE_FLOAT: u32 = 1u;\nconst TEXTURE_SRGB: u32 = 2u;\nconst TEXTURE_NEAREST: u32 = 4u;\nconst TEXTURE_FLIP_Y: u32 = 8u;\nconst TEXTURE_SINGLE: u32 = 32u;\n\n// Three's own wrap constants. Anything else clamps, as it does in the CPU renderer.\nconst WRAP_REPEAT: u32 = 1000u;\nconst WRAP_MIRROR: u32 = 1002u;\n\n/** Brings a texel index inside the texture the way the wrap mode says to. */\nfn wrapIndex(index: i32, size: i32, mode: u32) -> i32 {\n  if (mode == WRAP_REPEAT) {\n    return ((index % size) + size) % size;\n  }\n\n  if (mode == WRAP_MIRROR) {\n    let period = size * 2;\n    let folded = ((index % period) + period) % period;\n\n    return select(period - 1 - folded, folded, folded < size);\n  }\n\n  return clamp(index, 0, size - 1);\n}\n\n/** One texel, in linear light. Alpha is never encoded, as in Three. */\nfn readTexel(info: TextureInfo, x: i32, y: i32) -> vec4<f32> {\n  let index = u32(y) * info.size.x + u32(x);\n\n  if ((info.flags & TEXTURE_FLOAT) != 0u) {\n    let at = info.offset + index * 4u;\n\n    return vec4<f32>(\n      bitcast<f32>(textures[at]),\n      bitcast<f32>(textures[at + 1u]),\n      bitcast<f32>(textures[at + 2u]),\n      bitcast<f32>(textures[at + 3u]));\n  }\n\n  // The only channel the scene reads, four texels to a word, handed back in every channel: alpha as it is, the colour\n  // decoded where the texture is sRGB, as a full texel's would be.\n  if ((info.flags & TEXTURE_SINGLE) != 0u) {\n    let code = (textures[info.offset + (index >> 2u)] >> ((index & 3u) * 8u)) & 0xffu;\n    let raw = f32(code) / 255.0;\n    let colour = select(raw, bitcast<f32>(textures[SRGB_TABLE + code]), (info.flags & TEXTURE_SRGB) != 0u);\n\n    return vec4<f32>(colour, colour, colour, raw);\n  }\n\n  let word = textures[info.offset + index];\n\n  // The decode is a table of the 256 codes rather than a power per channel and per texel: the same values, read.\n  if ((info.flags & TEXTURE_SRGB) != 0u) {\n    return vec4<f32>(\n      bitcast<f32>(textures[SRGB_TABLE + (word & 0xffu)]),\n      bitcast<f32>(textures[SRGB_TABLE + ((word >> 8u) & 0xffu)]),\n      bitcast<f32>(textures[SRGB_TABLE + ((word >> 16u) & 0xffu)]),\n      f32((word >> 24u) & 0xffu) / 255.0);\n  }\n\n  return vec4<f32>(\n    f32(word & 0xffu),\n    f32((word >> 8u) & 0xffu),\n    f32((word >> 16u) & 0xffu),\n    f32((word >> 24u) & 0xffu)) / 255.0;\n}\n\n/** One texture of the table, sampled with its own transform, wrap modes and filter. */\nfn sampleTextureAt(index: u32, uv: vec2<f32>) -> vec4<f32> {\n  let info = textureInfo(index);\n  // The affine transform Three keeps on the texture, one row at a time.\n  let transformed = vec2<f32>(\n    dot(info.rowU.xyz, vec3<f32>(uv, 1.0)),\n    dot(info.rowV.xyz, vec3<f32>(uv, 1.0)));\n\n  return sampleTextureInfo(info, transformed);\n}\n\n/**\n * A texture read the way GLSL's texture2D reads it: at the coordinates given, with no transform. Three applies a\n * texture's matrix in its own materials' shaders, so a shader of the scene's, an environment lookup and a light's\n * projected map do not get it.\n */\nfn sampleTextureRaw(index: u32, uv: vec2<f32>) -> vec4<f32> {\n  return sampleTextureInfo(textureInfo(index), uv);\n}\n\n/** Three's equirectUv: longitude across, and latitude up from the bottom of the image, as GL reads it. */\nfn equirectUv(direction: vec3<f32>) -> vec2<f32> {\n  let d = normalize(direction);\n\n  return vec2<f32>(atan2(d.z, d.x) / (2.0 * PI) + 0.5, asin(clamp(d.y, -1.0, 1.0)) / PI + 0.5);\n}\n\n/** An environment map of the scene's: an equirectangular image, or a cube map the snapshot already unwrapped into one. */\nfn sampleEquirect(index: u32, direction: vec3<f32>) -> vec4<f32> {\n  return sampleTextureRaw(index, equirectUv(direction));\n}\n\nfn sampleTextureInfo(info: TextureInfo, transformed: vec2<f32>) -> vec4<f32> {\n  if (!all(transformed == transformed) || info.size.x == 0u || info.size.y == 0u) {\n    return vec4<f32>(0.0);\n  }\n\n  let flipped = select(transformed.y, 1.0 - transformed.y, (info.flags & TEXTURE_FLIP_Y) != 0u);\n  let size = vec2<i32>(info.size);\n  // The half texel offset that puts a sample in the middle of a texel, as on a graphics pipeline.\n  let centred = vec2<f32>(transformed.x, flipped) * vec2<f32>(info.size) - 0.5;\n\n  if ((info.flags & TEXTURE_NEAREST) != 0u) {\n    let at = vec2<i32>(floor(centred + 0.5));\n\n    return readTexel(info, wrapIndex(at.x, size.x, info.wrapS), wrapIndex(at.y, size.y, info.wrapT));\n  }\n\n  let low = floor(centred);\n  let fraction = centred - low;\n  let base = vec2<i32>(low);\n  let x0 = wrapIndex(base.x, size.x, info.wrapS);\n  let x1 = wrapIndex(base.x + 1, size.x, info.wrapS);\n  let y0 = wrapIndex(base.y, size.y, info.wrapT);\n  let y1 = wrapIndex(base.y + 1, size.y, info.wrapT);\n\n  // The four corners are blended in linear light, which is why the decode happens per texel above.\n  return mix(\n    mix(readTexel(info, x0, y0), readTexel(info, x1, y0), fraction.x),\n    mix(readTexel(info, x0, y1), readTexel(info, x1, y1), fraction.x),\n    fraction.y);\n}\n";
 //# sourceMappingURL=texture.wgsl.d.ts.map

package/dist/wgsl/texture.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/texture.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,66IAwHxB,CAAC"}
+{"version":3,"file":"texture.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/texture.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,89JAmIxB,CAAC"}

package/dist/wgsl/texture.wgsl.js

@@ -12,6 +12,7 @@ const TEXTURE_FLOAT: u32 = 1u;
 const TEXTURE_SRGB: u32 = 2u;
 const TEXTURE_NEAREST: u32 = 4u;
 const TEXTURE_FLIP_Y: u32 = 8u;
+const TEXTURE_SINGLE: u32 = 32u;
 
 // Three's own wrap constants. Anything else clamps, as it does in the CPU renderer.
 const WRAP_REPEAT: u32 = 1000u;
@@ -47,6 +48,16 @@ fn readTexel(info: TextureInfo, x: i32, y: i32) -> vec4<f32> {
       bitcast<f32>(textures[at + 3u]));
   }
 
+  // The only channel the scene reads, four texels to a word, handed back in every channel: alpha as it is, the colour
+  // decoded where the texture is sRGB, as a full texel's would be.
+  if ((info.flags & TEXTURE_SINGLE) != 0u) {
+    let code = (textures[info.offset + (index >> 2u)] >> ((index & 3u) * 8u)) & 0xffu;
+    let raw = f32(code) / 255.0;
+    let colour = select(raw, bitcast<f32>(textures[SRGB_TABLE + code]), (info.flags & TEXTURE_SRGB) != 0u);
+
+    return vec4<f32>(colour, colour, colour, raw);
+  }
+
   let word = textures[info.offset + index];
 
   // The decode is a table of the 256 codes rather than a power per channel and per texel: the same values, read.

package/dist/wgsl/texture.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"texture.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/texture.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwHtC,CAAC"}
+{"version":3,"file":"texture.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/texture.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmItC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinypoly/gpu-renderer",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "WebGPU path tracer for Three.js scenes: BVH traversal, progressive accumulation and tone mapping in WGSL compute shaders.",
   "keywords": [
     "three",

package/src/accumulator.ts

@@ -56,6 +56,7 @@ export class Accumulator {
 
   private create(): GPUBuffer {
     return this.device.createBuffer({
+      label: "accumulation",
       size: this.byteLength,
       // clearBuffer is a copy into the buffer: without COPY_DST it fails validation and clears nothing.
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,

package/src/denoise.ts

@@ -503,9 +503,9 @@ export class DenoisePass {
     const size = Math.max(16, width * height * 16);
 
     this.buffers = Array.from({ length: 6 }, () =>
-      this.device.createBuffer({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC }));
+      this.device.createBuffer({ label: "svgf", size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC }));
     this.buffers.push(
-      this.device.createBuffer({ size: Math.max(16, width * height * 4), usage: GPUBufferUsage.STORAGE }));
+      this.device.createBuffer({ label: "svgf", size: Math.max(16, width * height * 4), usage: GPUBufferUsage.STORAGE }));
     this.output = this.buffers[4];
     this.groups.clear();
     this.width = width;

package/src/device.ts

@@ -1,5 +1,7 @@
 /** Acquiring a device, and the questions a host asks before choosing this renderer at all. */
 
+import { logMemory, toMB, trackDevice } from "./memoryProbe.js";
+
 /** What the renderer needs from the platform, and what is missing when it cannot run. */
 export interface WebGpuSupport {
   /** True when an adapter answered. */
@@ -79,8 +81,18 @@ export async function requestRenderDevice(options: RenderDeviceOptions = {}): Pr
     },
   });
 
+  trackDevice(device);
   void device.lost.then(info => options.onLost?.(info.message || String(info.reason)));
 
+  const info = (adapter as GPUAdapter & { info?: GPUAdapterInfo }).info;
+
+  logMemory("device acquired", {
+    adapter: info ? `${info.vendor} ${info.architecture} ${info.device} ${info.description}`.trim() : "unknown",
+    maxBufferMB: toMB(device.limits.maxBufferSize),
+    maxStorageBindingMB: toMB(device.limits.maxStorageBufferBindingSize),
+    shaderF16: requiredFeatures.length > 0,
+  });
+
   return {
     adapter,
     device,

package/src/frameLayout.ts

@@ -49,6 +49,11 @@ export const FRAME_LAYOUT = layoutStruct("Frame", [
   { name: "colorOffset", type: "u32", doc: "Where vertex colours start inside the attribute buffer." },
   { name: "hasColors", type: "u32" },
   { name: "varyingOffset", type: "u32", doc: "Where shader varyings start inside the attribute buffer." },
+  { name: "sceneTriangles", type: "u32", doc: "Triangles of the scene's own; the instances' are numbered after them." },
+  { name: "instanceOffset", type: "u32", doc: "Where the instance of every instanced triangle starts inside the index buffer." },
+  { name: "cornerOffset", type: "u32", doc: "Where the three vertices of every stored triangle start inside the index buffer." },
+  { name: "normalOffset", type: "u32", doc: "Where the vertices' folded normals start inside the index buffer." },
+  { name: "instanceData", type: "u32", doc: "Where the instances' transforms start in the texture buffer." },
   { name: "environmentTexture", type: "u32", doc: "The surrounding image, or NO_TEXTURE for the gradient." },
   { name: "environmentCdf", type: "u32" },
   { name: "environmentCdfSize", type: "vec2u" },