@tinypoly/gpu-renderer 0.0.4 → 0.1.0

package/src/wgsl/sampling.wgsl.ts

@@ -21,6 +21,31 @@ fn cosineDirection(normal: vec3<f32>, u: vec2<f32>) -> vec3<f32> {
   return normalize(orthonormalBasis(normal) * local);
 }
 
+/** A direction scattered from forward by the Henyey-Greenstein phase function, which its own sampling cancels. */
+fn sampleHenyeyGreenstein(forward: vec3<f32>, g: f32, u: vec2<f32>) -> vec3<f32> {
+  var cosine = 1.0 - 2.0 * u.x;
+
+  if (abs(g) > 1e-3) {
+    let s = (1.0 - g * g) / (1.0 - g + 2.0 * g * u.x);
+    cosine = clamp((1.0 + g * g - s * s) / (2.0 * g), -1.0, 1.0);
+  }
+
+  let sine = sqrt(max(0.0, 1.0 - cosine * cosine));
+  let angle = 2.0 * PI * u.y;
+
+  return normalize(orthonormalBasis(forward) * vec3<f32>(sine * cos(angle), sine * sin(angle), cosine));
+}
+
+/**
+ * The Henyey-Greenstein phase function, per steradian, for a turn whose cosine is given from the direction of travel:
+ * the density sampleHenyeyGreenstein draws with.
+ */
+fn henyeyGreenstein(cosine: f32, g: f32) -> f32 {
+  let denominator = 1.0 + g * g - 2.0 * g * cosine;
+
+  return (1.0 - g * g) / (4.0 * PI * denominator * sqrt(max(denominator, 1e-12)));
+}
+
 /** The unit normal of the triangle's plane; which side it faces does not matter, every emitter is two sided. */
 fn triangleNormal(triangle: u32) -> vec3<f32> {
   let a = triangleVertex(triangle, 0u);

package/src/wgsl/surface.wgsl.ts

@@ -62,6 +62,8 @@ struct Surface {
   lightMap: vec3<f32>,
   blending: u32,
   material: u32,
+  // Share of the diffuse layer that scatters inside the material instead of at its surface.
+  subsurface: f32,
 };
 
 /** Barycentric weights of the two trailing vertices, for a point drawn uniformly over a triangle's area. */
@@ -114,6 +116,18 @@ fn isCulled(material: u32, triangle: u32, direction: vec3<f32>) -> bool {
 /** What the triangle radiates at this point, its emissive map included so direct and indirect light agree on it. */
 fn emissionAt(triangle: u32, bary: vec2<f32>) -> vec3<f32> {
   let m = materialIndexOf(triangle);
+
+  // An unlit material emits its colour as the camera would see it, so a bounce ray finds what a light sample counted.
+  if ((materials[m].flags & MATERIAL_UNLIT_LIGHT) != 0u) {
+    var color = materials[m].color.rgb * sampleMap(materials[m].map, triangle, bary).rgb;
+
+    if ((materials[m].flags & MATERIAL_VERTEX_COLORS) != 0u) {
+      color = color * triangleColor(triangle, bary).rgb;
+    }
+
+    return color;
+  }
+
   let map = sampleMap(materials[m].emissiveMap, triangle, bary);
 
   return materials[m].emissive.rgb * materials[m].emissive.w * map.rgb;
@@ -173,8 +187,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 +572,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;
@@ -588,7 +625,12 @@ fn resolveSurface(triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> Surfa
 
   var roughness = materials[m].specular.w * sampleMap(materials[m].roughnessMap, triangle, bary).g;
   var metalness = materials[m].metalness * sampleMap(materials[m].metalnessMap, triangle, bary).b;
-  var emissive = emissionAt(triangle, bary);
+  var emissive = vec3<f32>(0.0);
+
+  // An unlit light's colour is added as what it shows, below; emissionAt gives the same colour to light samples.
+  if ((flags & MATERIAL_UNLIT_LIGHT) == 0u) {
+    emissive = emissionAt(triangle, bary);
+  }
 
   surface.opacity = 1.0;
 
@@ -635,6 +677,7 @@ fn resolveSurface(triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> Surfa
   surface.ior = max(materials[m].ior, 1.0);
   surface.thickness = materials[m].thickness * sampleMap(materials[m].thicknessMap, triangle, bary).g;
   surface.dispersion = materials[m].dispersion;
+  surface.subsurface = select(0.0, materials[m].subsurface.w, frame.subsurfaceEnabled != 0u);
   surface.absorption = absorptionOf(m);
   surface.shininess = materials[m].shininess;
   surface.specularStrength = sampleMap(materials[m].specularMap, triangle, bary).r;

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. */