@tinypoly/gpu-renderer 0.0.5 → 0.1.1

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;
@@ -611,7 +625,12 @@ fn resolveSurfaceFrom(triangle: u32, bary: vec2<f32>, direction: vec3<f32>, base
 
   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;
 
@@ -658,6 +677,7 @@ fn resolveSurfaceFrom(triangle: u32, bary: vec2<f32>, direction: vec3<f32>, base
   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;