@tinypoly/gpu-renderer 0.2.4 → 0.3.0

package/src/wgsl/common.wgsl.ts

@@ -137,13 +137,16 @@ const TEXTURE_TABLE: u32 = ${TEXTURE_TABLE}u;
 // A WebGPU device only has to offer eight storage buffers per stage, so arrays of the same kind share one binding and
 // the uniform says where the second one starts. See sceneUpload.ts, which joins them.
 @group(0) @binding(0) var<uniform> frame: Frame;
-// Nine coordinates per triangle, in the hierarchy's leaf order: see leafOf in bvh.wgsl.ts.
+// Nine coordinates per stored triangle, in the hierarchy's leaf order: see leafOf in bvh.wgsl.ts. A prototype's are
+// in object space.
 @group(0) @binding(1) var<storage, read> positions: array<f32>;
-// Normals, then the UV sets from frame.uvOffset, vertex colours from frame.colorOffset and shader varyings from
-// frame.varyingOffset.
+// Per vertex: the UV sets from frame.uvOffset and vertex colours from frame.colorOffset; then shader varyings, per
+// corner, from frame.varyingOffset.
 @group(0) @binding(2) var<storage, read> attributes: array<f32>;
-// One material index per triangle, then the hierarchy's triangle order from frame.orderOffset on (the triangle at each
-// position of the leaf order), then from frame.leafOffset on the other way (the position of each triangle).
+// One material index per triangle a hit can name, then the hierarchy's triangle order from frame.orderOffset on (the
+// stored triangle at each position of the leaf order), then from frame.leafOffset on the other way (the position of
+// each stored triangle), the instance of every instanced triangle from frame.instanceOffset, the three vertices of each
+// stored triangle from frame.cornerOffset and every vertex's folded normal from frame.normalOffset.
 @group(0) @binding(3) var<storage, read> indices: array<u32>;
 @group(0) @binding(4) var<storage, read> materials: array<Material>;
 @group(0) @binding(5) var<storage, read> nodes: array<BvhNode>;
@@ -163,24 +166,102 @@ fn orderedTriangle(at: u32) -> u32 {
   return indices[frame.orderOffset + at];
 }
 
-/** One word of a UV set: three vertices of four components, two per set. */
-fn attributeUv(triangle: u32, corner: u32, channel: u32) -> vec2<f32> {
-  let at = frame.uvOffset + triangle * 12u + corner * 4u + channel * 2u;
+/** What a triangle of the scene's own belongs to: no instance. */
+const NO_INSTANCE: u32 = 0xffffffffu;
+
+/** The instance a triangle a hit named belongs to, or NO_INSTANCE for one of the scene's own. */
+fn instanceOf(triangle: u32) -> u32 {
+  if (!INSTANCES || triangle < frame.sceneTriangles) {
+    return NO_INSTANCE;
+  }
+
+  return indices[frame.instanceOffset + triangle - frame.sceneTriangles];
+}
+
+/** One word of an instance's record: see INSTANCE_WORDS in instancing.ts. */
+fn instanceWord(instance: u32, word: u32) -> u32 {
+  return textures[frame.instanceData + instance * 28u + word];
+}
+
+/** A row of an instance's transforms: 0 to 2 take object space to world, 3 to 5 back. */
+fn instanceRow(instance: u32, row: u32) -> vec4<f32> {
+  let at = frame.instanceData + instance * 28u + row * 4u;
+
+  return vec4<f32>(bitcast<f32>(textures[at]), bitcast<f32>(textures[at + 1u]), bitcast<f32>(textures[at + 2u]),
+    bitcast<f32>(textures[at + 3u]));
+}
+
+/** Where a named triangle is stored: itself, or for an instance's, the prototype's triangle it repeats. */
+fn storedTriangle(triangle: u32, instance: u32) -> u32 {
+  if (instance == NO_INSTANCE) {
+    return triangle;
+  }
+
+  return instanceWord(instance, 25u) + triangle - instanceWord(instance, 26u);
+}
+
+/** A point of an instance's prototype, in world space. */
+fn instancePoint(instance: u32, p: vec3<f32>) -> vec3<f32> {
+  let q = vec4<f32>(p, 1.0);
+
+  return vec3<f32>(dot(instanceRow(instance, 0u), q), dot(instanceRow(instance, 1u), q), dot(instanceRow(instance, 2u), q));
+}
+
+/** A world space point (w 1) or direction (w 0), in an instance's object space. */
+fn instanceToObject(instance: u32, v: vec3<f32>, w: f32) -> vec3<f32> {
+  let q = vec4<f32>(v, w);
+
+  return vec3<f32>(dot(instanceRow(instance, 3u), q), dot(instanceRow(instance, 4u), q), dot(instanceRow(instance, 5u), q));
+}
+
+/** An object space normal in world space, by the inverse transpose; not normalized. */
+fn instanceNormal(instance: u32, n: vec3<f32>) -> vec3<f32> {
+  return n.x * instanceRow(instance, 3u).xyz + n.y * instanceRow(instance, 4u).xyz + n.z * instanceRow(instance, 5u).xyz;
+}
+
+/** The three vertices of a triangle a hit named. */
+fn triangleCorners(triangle: u32) -> vec3<u32> {
+  let at = frame.cornerOffset + storedTriangle(triangle, instanceOf(triangle)) * 3u;
+
+  return vec3<u32>(indices[at], indices[at + 1u], indices[at + 2u]);
+}
+
+/** One UV set of a vertex: four components, two per set. */
+fn vertexUv(vertex: u32, channel: u32) -> vec2<f32> {
+  let at = frame.uvOffset + vertex * 4u + channel * 2u;
 
   return vec2<f32>(attributes[at], attributes[at + 1u]);
 }
 
-/** A corner's vertex colour, or white when the scene has none. */
-fn attributeColor(triangle: u32, corner: u32) -> vec4<f32> {
+/** A vertex's colour, or white when the scene has none. */
+fn vertexColor(vertex: u32) -> vec4<f32> {
   if (frame.hasColors == 0u) {
     return vec4<f32>(1.0);
   }
 
-  let at = frame.colorOffset + triangle * 12u + corner * 4u;
+  let at = frame.colorOffset + vertex * 4u;
 
   return vec4<f32>(attributes[at], attributes[at + 1u], attributes[at + 2u], attributes[at + 3u]);
 }
 
+/** A normal folded onto an octahedron in two signed 16 bit halves, as sceneUpload.ts folds it; zero for NO_NORMAL. */
+fn vertexNormal(vertex: u32) -> vec3<f32> {
+  let code = indices[frame.normalOffset + vertex];
+
+  if (code == 0x80008000u) {
+    return vec3<f32>(0.0);
+  }
+
+  let e = unpack2x16snorm(code);
+  var n = vec3<f32>(e.x, e.y, 1.0 - abs(e.x) - abs(e.y));
+  let t = max(-n.z, 0.0);
+
+  n.x = n.x + select(t, -t, n.x >= 0.0);
+  n.y = n.y + select(t, -t, n.y >= 0.0);
+
+  return normalize(n);
+}
+
 fn extraFloat(at: u32) -> f32 {
   return bitcast<f32>(textures[at]);
 }

package/src/wgsl/lens.wgsl.ts

@@ -50,6 +50,8 @@ struct Lens {
   autoExposure: f32,
   // The share of a dark scene's darkness the meter keeps.
   darkAdaptation: f32,
+  // The exposure applied after the lens, the meter's aside, which the rays are limited against.
+  exposure: f32,
 };
 
 const PI: f32 = 3.14159265358979;
@@ -57,6 +59,12 @@ const PI: f32 = 3.14159265358979;
 /** Taps along each of the aperture's rays. */
 const STREAK_TAPS: i32 = 24;
 
+/**
+ * The brightest a tap of the rays counts as, in multiples of the exposed white. A lamp is thousands of times white,
+ * which would carry its rays across the frame at full length; past this they stay as short as a camera shows them.
+ */
+const GLARE_CEILING: f32 = 4.0;
+
 @group(0) @binding(0) var<uniform> lens: Lens;
 @group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;
 @group(0) @binding(2) var<storage, read> denoised: array<vec4<f32>>;
@@ -342,6 +350,8 @@ fn streaks(@builtin(global_invocation_id) id: vec3<u32>) {
   }
 
   let centre = vec2<f32>(id.xy) + 0.5;
+  // The exposure the image will have: the setting's, and the meter's when it meters.
+  let exposure = lens.exposure * select(1.0, metered[0].x, lens.autoExposure > 0.0);
   var sum = vec3<f32>(0.0);
   var total = 0.0;
 
@@ -351,9 +361,11 @@ fn streaks(@builtin(global_invocation_id) id: vec3<u32>) {
 
     for (var j = 1; j <= STREAK_TAPS; j = j + 1) {
       let t = f32(j) / f32(STREAK_TAPS);
-      let weight = exp(-4.0 * t);
+      let weight = exp(-6.0 * t);
+
+      let light = downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength));
 
-      sum = sum + downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength)) * weight;
+      sum = sum + light * (weight / max(1.0, luminance(light) * exposure / GLARE_CEILING));
       total = total + weight;
     }
   }

package/src/wgsl/surface.wgsl.ts

@@ -82,15 +82,19 @@ fn trianglePointAt(triangle: u32, bary: vec2<f32>) -> vec3<f32> {
 }
 
 fn triangleUv(triangle: u32, bary: vec2<f32>, channel: u32) -> vec2<f32> {
-  return attributeUv(triangle, 0u, channel) * (1.0 - bary.x - bary.y)
-    + attributeUv(triangle, 1u, channel) * bary.x
-    + attributeUv(triangle, 2u, channel) * bary.y;
+  let corners = triangleCorners(triangle);
+
+  return vertexUv(corners.x, channel) * (1.0 - bary.x - bary.y)
+    + vertexUv(corners.y, channel) * bary.x
+    + vertexUv(corners.z, channel) * bary.y;
 }
 
 fn triangleColor(triangle: u32, bary: vec2<f32>) -> vec4<f32> {
-  return attributeColor(triangle, 0u) * (1.0 - bary.x - bary.y)
-    + attributeColor(triangle, 1u) * bary.x
-    + attributeColor(triangle, 2u) * bary.y;
+  let corners = triangleCorners(triangle);
+
+  return vertexColor(corners.x) * (1.0 - bary.x - bary.y)
+    + vertexColor(corners.y) * bary.x
+    + vertexColor(corners.z) * bary.y;
 }
 
 /** A map slot, sampled through the UV set the texture asks for. Missing maps read as one, so a multiply is always safe. */
@@ -362,9 +366,10 @@ fn tangentFrame(triangle: u32, channel: u32, normal: vec3<f32>) -> TangentFrame
   let p0 = triangleVertex(triangle, 0u);
   let edge1 = triangleVertex(triangle, 1u) - p0;
   let edge2 = triangleVertex(triangle, 2u) - p0;
-  let uv0 = attributeUv(triangle, 0u, channel);
-  let delta1 = attributeUv(triangle, 1u, channel) - uv0;
-  let delta2 = attributeUv(triangle, 2u, channel) - uv0;
+  let corners = triangleCorners(triangle);
+  let uv0 = vertexUv(corners.x, channel);
+  let delta1 = vertexUv(corners.y, channel) - uv0;
+  let delta2 = vertexUv(corners.z, channel) - uv0;
   let determinant = delta1.x * delta2.y - delta2.x * delta1.y;
 
   // A triangle with no UV area has no tangent frame to offer.
@@ -460,12 +465,17 @@ fn mappedNormal(m: u32, triangle: u32, bary: vec2<f32>, normal: vec3<f32>) -> ve
 
 /** The interpolated vertex normal as the mesh authored it, pointing out of a closed volume. */
 fn authoredNormal(triangle: u32, bary: vec2<f32>) -> vec3<f32> {
-  let base = triangle * 9u;
-  let n0 = vec3<f32>(attributes[base], attributes[base + 1u], attributes[base + 2u]);
-  let n1 = vec3<f32>(attributes[base + 3u], attributes[base + 4u], attributes[base + 5u]);
-  let n2 = vec3<f32>(attributes[base + 6u], attributes[base + 7u], attributes[base + 8u]);
+  let instance = instanceOf(triangle);
+  let at = frame.cornerOffset + storedTriangle(triangle, instance) * 3u;
+  let n = vertexNormal(indices[at]) * (1.0 - bary.x - bary.y)
+    + vertexNormal(indices[at + 1u]) * bary.x
+    + vertexNormal(indices[at + 2u]) * bary.y;
+
+  if (instance != NO_INSTANCE) {
+    return normalize(instanceNormal(instance, n));
+  }
 
-  return normalize(n0 * (1.0 - bary.x - bary.y) + n1 * bary.x + n2 * bary.y);
+  return normalize(n);
 }
 
 /** The interpolated vertex normal, or the face's for flat shading, turned to face the ray. */

package/src/wgsl/texture.wgsl.ts

@@ -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.