@tinypoly/gpu-renderer 0.0.3 → 0.0.5

package/src/wgsl/pathTrace.wgsl.ts

@@ -330,7 +330,21 @@ fn traceRadiance(
       continue;
     }
 
-    let surface = resolveSurface(hit.triangle, bary, direction);
+    let base = sampleMap(materials[m].map, hit.triangle, bary);
+
+    // A cutout lets the ray through before anything else about the surface is read: the normal map, the other maps and
+    // the lobes would only be thrown away. The draw and the comparison are the ones made below, so nothing changes.
+    if (coverageFirst(m)) {
+      let opacity = coverageOf(m, materialAlphaFrom(m, hit.triangle, bary, base));
+
+      if (opacity < 1.0 && coverage.x >= opacity) {
+        origin = point + direction * RAY_EPSILON;
+        limit = select(1e30, limit - hit.distance, straight);
+        continue;
+      }
+    }
+
+    let surface = resolveSurfaceFrom(hit.triangle, bary, direction, base);
 
     // Blending other than normal: the surface adds its light to, or filters, whatever is behind it, and the path goes on.
     if (surface.blending == BLEND_ADDITIVE || surface.blending == BLEND_MULTIPLY || surface.blending == BLEND_SUBTRACTIVE) {

package/src/wgsl/random.wgsl.ts

@@ -46,24 +46,16 @@ fn nestedScramble(value: u32, seed: u32) -> u32 {
   return reverseBits(laineKarras(reverseBits(value), seed));
 }
 
-/** The first two Sobol dimensions, as fixed point fractions. */
+/**
+ * The first two Sobol dimensions, as fixed point fractions. The second is the index times Pascal's triangle mod 2,
+ * which is linear in the bits of the index, so it is read one byte at a time from the tables texturePack.ts writes
+ * instead of folded in one bit at a time: four reads where the scrambled index made it thirty two steps.
+ */
 fn sobol2(index: u32) -> vec2<u32> {
-  var second = 0u;
-  var direction = 0x80000000u;
-  var bits = index;
-
-  loop {
-    if (bits == 0u) {
-      break;
-    }
-
-    if ((bits & 1u) != 0u) {
-      second = second ^ direction;
-    }
-
-    bits = bits >> 1u;
-    direction = direction ^ (direction >> 1u);
-  }
+  let second = textures[SOBOL_TABLE + (index & 0xffu)]
+    ^ textures[SOBOL_TABLE + 256u + ((index >> 8u) & 0xffu)]
+    ^ textures[SOBOL_TABLE + 512u + ((index >> 16u) & 0xffu)]
+    ^ textures[SOBOL_TABLE + 768u + (index >> 24u)];
 
   return vec2<u32>(reverseBits(index), second);
 }

package/src/wgsl/surface.wgsl.ts

@@ -173,8 +173,12 @@ fn onWireframe(triangle: u32, point: vec3<f32>) -> bool {
 
 /** Three's diffuseColor.a: opacity, the colour map's alpha, the alpha map's green and the vertex alpha. */
 fn materialAlpha(m: u32, triangle: u32, bary: vec2<f32>) -> f32 {
-  var alpha = materials[m].color.w * sampleMap(materials[m].map, triangle, bary).a
-    * sampleMap(materials[m].alphaMap, triangle, bary).g;
+  return materialAlphaFrom(m, triangle, bary, sampleMap(materials[m].map, triangle, bary));
+}
+
+/** The same, from the colour map's texel at this point. Multiplied in the order resolveSurface multiplies it. */
+fn materialAlphaFrom(m: u32, triangle: u32, bary: vec2<f32>, base: vec4<f32>) -> f32 {
+  var alpha = materials[m].color.w * base.a * sampleMap(materials[m].alphaMap, triangle, bary).g;
 
   if ((materials[m].flags & MATERIAL_VERTEX_COLORS) != 0u) {
     alpha = alpha * triangleColor(triangle, bary).a;
@@ -554,12 +558,31 @@ fn toonRamp(gradientMap: u32, cosine: f32) -> f32 {
   return sampleTextureRaw(gradientMap, vec2<f32>(coordinate, 0.0)).r;
 }
 
+/**
+ * Whether a material's coverage can be told from its maps alone, before the rest of the surface is read: no shader that
+ * might rewrite the alpha or discard, normal blending, and something that makes it partial at all.
+ */
+fn coverageFirst(m: u32) -> bool {
+  let flags = materials[m].flags;
+  let blending = materials[m].blending;
+
+  return materials[m].program == NO_PROGRAM
+    && (blending == BLEND_NORMAL || blending == BLEND_NONE)
+    && (materials[m].alphaTest > 0.0 || (flags & (MATERIAL_ALPHA_HASH | MATERIAL_TRANSPARENT)) != 0u);
+}
+
 /** Everything the lobes need about one point of one triangle. */
 fn resolveSurface(triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> Surface {
   let m = materialIndexOf(triangle);
+
+  return resolveSurfaceFrom(triangle, bary, direction, sampleMap(materials[m].map, triangle, bary));
+}
+
+/** The same, from the colour map's texel at this point, for a caller that already read it. */
+fn resolveSurfaceFrom(triangle: u32, bary: vec2<f32>, direction: vec3<f32>, base: vec4<f32>) -> Surface {
+  let m = materialIndexOf(triangle);
   let flags = materials[m].flags;
   let kind = materials[m].kind;
-  let base = sampleMap(materials[m].map, triangle, bary);
   let facing = interpolatedNormal(m, triangle, bary, direction);
   let view = -direction;
   var surface: Surface;

package/src/wgsl/texture.wgsl.ts

@@ -33,10 +33,6 @@ fn wrapIndex(index: i32, size: i32, mode: u32) -> i32 {
   return clamp(index, 0, size - 1);
 }
 
-fn srgbChannelToLinear(value: f32) -> f32 {
-  return select(pow((value + 0.055) / 1.055, 2.4), value / 12.92, value <= 0.04045);
-}
-
 /** One texel, in linear light. Alpha is never encoded, as in Three. */
 fn readTexel(info: TextureInfo, x: i32, y: i32) -> vec4<f32> {
   let index = u32(y) * info.size.x + u32(x);
@@ -52,18 +48,21 @@ fn readTexel(info: TextureInfo, x: i32, y: i32) -> vec4<f32> {
   }
 
   let word = textures[info.offset + index];
-  let raw = vec4<f32>(
-    f32(word & 0xffu),
-    f32((word >> 8u) & 0xffu),
-    f32((word >> 16u) & 0xffu),
-    f32((word >> 24u) & 0xffu)) / 255.0;
 
+  // The decode is a table of the 256 codes rather than a power per channel and per texel: the same values, read.
   if ((info.flags & TEXTURE_SRGB) != 0u) {
     return vec4<f32>(
-      srgbChannelToLinear(raw.r), srgbChannelToLinear(raw.g), srgbChannelToLinear(raw.b), raw.a);
+      bitcast<f32>(textures[SRGB_TABLE + (word & 0xffu)]),
+      bitcast<f32>(textures[SRGB_TABLE + ((word >> 8u) & 0xffu)]),
+      bitcast<f32>(textures[SRGB_TABLE + ((word >> 16u) & 0xffu)]),
+      f32((word >> 24u) & 0xffu) / 255.0);
   }
 
-  return raw;
+  return vec4<f32>(
+    f32(word & 0xffu),
+    f32((word >> 8u) & 0xffu),
+    f32((word >> 16u) & 0xffu),
+    f32((word >> 24u) & 0xffu)) / 255.0;
 }
 
 /** One texture of the table, sampled with its own transform, wrap modes and filter. */