@tinypoly/gpu-renderer 0.0.0-stage → 0.0.0

package/src/wgsl/present.wgsl.ts

@@ -0,0 +1,153 @@
+/**
+ * The presentation pass: divides the accumulation buffer by its sample count and applies exposure, tone mapping,
+ * vignette and grain. The operators are ports of `color.ts` in the CPU renderer, which are in turn Three's ACES, AgX
+ * and Khronos neutral curves, so the two renderers agree on the display transform even when they disagree on the light.
+ */
+export const PRESENT_WGSL = /* wgsl */ `
+struct Present {
+  resolution: vec2<u32>,
+  exposure: f32,
+  toneMapping: u32,
+  vignette: f32,
+  grain: f32,
+  frameIndex: u32,
+  // A transparent background: the canvas gets the coverage as alpha, premultiplied as it is configured.
+  transparent: u32,
+  // Whether the colour comes from the denoiser's output rather than straight from the accumulation.
+  denoised: u32,
+};
+
+@group(0) @binding(0) var<uniform> present: Present;
+@group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> denoised: array<vec4<f32>>;
+
+@vertex
+fn vertexMain(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {
+  // One oversized triangle covers the viewport with no vertex buffer.
+  let x = f32(index / 2u) * 4.0 - 1.0;
+  let y = f32(index & 1u) * 4.0 - 1.0;
+
+  return vec4<f32>(x, y, 0.0, 1.0);
+}
+
+fn toneMapAces(color: vec3<f32>) -> vec3<f32> {
+  let toAces = mat3x3<f32>(
+    vec3<f32>(0.59719, 0.076, 0.0284),
+    vec3<f32>(0.35458, 0.90834, 0.13383),
+    vec3<f32>(0.04823, 0.01566, 0.83777));
+  let fromAces = mat3x3<f32>(
+    vec3<f32>(1.60475, -0.10208, -0.00327),
+    vec3<f32>(-0.53108, 1.10813, -0.07276),
+    vec3<f32>(-0.07367, -0.00605, 1.07602));
+  let v = toAces * (color / 0.6);
+
+  return fromAces * ((v * (v + 0.0245786) - 0.000090537) / (v * (0.983729 * v + 0.432951) + 0.238081));
+}
+
+fn toneMapAgx(color: vec3<f32>) -> vec3<f32> {
+  let toAgx = mat3x3<f32>(
+    vec3<f32>(0.6274, 0.0691, 0.0164),
+    vec3<f32>(0.3293, 0.9195, 0.088),
+    vec3<f32>(0.0433, 0.0113, 0.8956));
+  let inset = mat3x3<f32>(
+    vec3<f32>(0.856627153315983, 0.137318972929847, 0.11189821299995),
+    vec3<f32>(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
+    vec3<f32>(0.0482516061458583, 0.101439036467562, 0.811302368396859));
+  let outset = mat3x3<f32>(
+    vec3<f32>(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
+    vec3<f32>(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
+    vec3<f32>(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405));
+  let fromAgx = mat3x3<f32>(
+    vec3<f32>(1.6605, -0.1246, -0.0182),
+    vec3<f32>(-0.5876, 1.1329, -0.1006),
+    vec3<f32>(-0.0728, -0.0083, 1.1187));
+  let logged = inset * (toAgx * color);
+  let x = clamp((log2(max(logged, vec3<f32>(1e-10))) + 12.47393) / 16.499999, vec3<f32>(0.0), vec3<f32>(1.0));
+  let curved = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))
+    - 6.868 * pow(x, vec3<f32>(3.0)) + 0.4298 * x * x + 0.1191 * x - 0.00232;
+
+  return fromAgx * pow(max(outset * curved, vec3<f32>(0.0)), vec3<f32>(2.2));
+}
+
+fn toneMapNeutral(color: vec3<f32>) -> vec3<f32> {
+  let low = min(color.r, min(color.g, color.b));
+  let offset = select(0.04, low - 6.25 * low * low, low < 0.08);
+  let shifted = color - offset;
+  let peak = max(shifted.r, max(shifted.g, shifted.b));
+
+  if (peak < 0.76) {
+    return shifted;
+  }
+
+  let newPeak = 1.0 - 0.24 * 0.24 / (peak + 0.24 - 0.76);
+  let g = 1.0 - 1.0 / (0.15 * (peak - newPeak) + 1.0);
+
+  return shifted * (newPeak / peak) * (1.0 - g) + newPeak * g;
+}
+
+fn toneMap(color: vec3<f32>) -> vec3<f32> {
+  let exposed = max(color * present.exposure, vec3<f32>(0.0));
+  var mapped = exposed;
+
+  if (present.toneMapping == 0u) {
+    mapped = toneMapAces(exposed);
+  } else if (present.toneMapping == 1u) {
+    mapped = toneMapAgx(exposed);
+  } else if (present.toneMapping == 2u) {
+    mapped = toneMapNeutral(exposed);
+  }
+
+  return clamp(mapped, vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+fn linearToSrgb(color: vec3<f32>) -> vec3<f32> {
+  let low = color * 12.92;
+  let high = 1.055 * pow(max(color, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;
+
+  return select(high, low, color <= vec3<f32>(0.0031308));
+}
+
+fn hash(value: u32) -> f32 {
+  var state = value * 747796405u + 2891336453u;
+  state = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+
+  return f32((state >> 22u) ^ state) * 2.3283064365386963e-10;
+}
+
+@fragment
+fn fragmentMain(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
+  let pixel = vec2<u32>(position.xy);
+  let index = pixel.y * present.resolution.x + pixel.x;
+  let stored = accumulation[index];
+
+  // Nothing has been traced into this pixel yet: it stays see-through, so whatever is under the canvas shows.
+  if (stored.w <= 0.0) {
+    return vec4<f32>(0.0);
+  }
+
+  var color = select(stored.rgb / stored.w, vec3<f32>(0.0), stored.w <= 0.0);
+
+  if (present.denoised != 0u) {
+    color = denoised[index].rgb;
+  }
+  var alpha = 1.0;
+
+  if (present.transparent != 0u) {
+    let coverage = accumulation[present.resolution.x * present.resolution.y + index].x;
+    alpha = select(clamp(coverage / stored.w, 0.0, 1.0), 0.0, stored.w <= 0.0);
+    // The radiance is premultiplied by the coverage; the tone curve applies to the colour itself.
+    color = select(color / alpha, vec3<f32>(0.0), alpha <= 0.0);
+  }
+
+  let centred = position.xy / vec2<f32>(present.resolution) - 0.5;
+  let falloff = 1.0 - present.vignette * dot(centred, centred) * 2.0;
+  var output = linearToSrgb(toneMap(color * max(falloff, 0.0)));
+
+  if (present.grain > 0.0) {
+    let noise = hash(index * 9781u + present.frameIndex * 6151u) - 0.5;
+    output = clamp(output + noise * present.grain * 0.1, vec3<f32>(0.0), vec3<f32>(1.0));
+  }
+
+  return vec4<f32>(output * alpha, alpha);
+}
+`;

package/src/wgsl/random.wgsl.ts

@@ -0,0 +1,90 @@
+/**
+ * The sample generator: a Sobol sequence with hash based Owen scrambling (Burley, "Practical Hash-based Owen
+ * Scrambling", 2020). Every pixel draws its own scrambled sequence, decorrelated from its neighbours, and inside a pixel
+ * the samples are stratified in every pair of dimensions, so the estimate converges faster than with independent
+ * random numbers. Only the sample index, the pixel and a dimension counter feed the generator, so a pixel draws the same
+ * numbers whichever dispatch happens to cover it and the image does not depend on the tiling.
+ */
+export const RANDOM_WGSL = /* wgsl */ `
+fn pcgHash(value: u32) -> u32 {
+  let state = value * 747796405u + 2891336453u;
+  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+
+  return (word >> 22u) ^ word;
+}
+
+struct PathSampler {
+  seed: u32,
+  index: u32,
+  dimension: u32,
+};
+
+fn makeSampler(pixel: vec2<u32>, index: u32) -> PathSampler {
+  var rng: PathSampler;
+  rng.seed = pcgHash(pixel.x * 1973u + pixel.y * 9277u + 1u);
+  rng.index = index;
+  rng.dimension = 0u;
+
+  return rng;
+}
+
+/**
+ * The Laine-Karras hash, which permutes the high bits in a way that nests: what Owen scrambling asks for. Every
+ * multiplier has to be even, or a bit stops depending on itself and the map is no longer a permutation.
+ */
+fn laineKarras(value: u32, seed: u32) -> u32 {
+  var x = value + seed;
+  x = x ^ (x * 0x6c50b47cu);
+  x = x ^ (x * 0xb82f1e52u);
+  x = x ^ (x * 0xc7afe784u);
+  x = x ^ (x * 0x8d22f6e6u);
+
+  return x;
+}
+
+fn nestedScramble(value: u32, seed: u32) -> u32 {
+  return reverseBits(laineKarras(reverseBits(value), seed));
+}
+
+/** The first two Sobol dimensions, as fixed point fractions. */
+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);
+  }
+
+  return vec2<u32>(reverseBits(index), second);
+}
+
+fn toUnit(value: u32) -> f32 {
+  return min(f32(value) * 2.3283064365386963e-10, 0.99999994);
+}
+
+/**
+ * The next pair of dimensions, in [0, 1). The sample index is shuffled per pair as well, which pads the two dimensional
+ * sequence out to as many dimensions as a path needs without correlating them.
+ */
+fn sample2D(rng: ptr<function, PathSampler>) -> vec2<f32> {
+  let pair = (*rng).seed + (*rng).dimension * 2654435761u;
+  (*rng).dimension = (*rng).dimension + 1u;
+
+  let shuffled = nestedScramble((*rng).index, pcgHash(pair));
+  let point = sobol2(shuffled);
+
+  return vec2<f32>(
+    toUnit(nestedScramble(point.x, pcgHash(pair + 0x9e3779b9u))),
+    toUnit(nestedScramble(point.y, pcgHash(pair + 0x3c6ef372u))));
+}
+`;

package/src/wgsl/sampling.wgsl.ts

@@ -0,0 +1,30 @@
+/** The geometric primitives the lobes and the light sampling are built from. */
+export const SAMPLING_WGSL = /* wgsl */ `
+/** Branchless orthonormal basis around a unit normal (Duff and others, 2017). */
+fn orthonormalBasis(n: vec3<f32>) -> mat3x3<f32> {
+  let s = select(-1.0, 1.0, n.z >= 0.0);
+  let a = -1.0 / (s + n.z);
+  let b = n.x * n.y * a;
+
+  return mat3x3<f32>(
+    vec3<f32>(1.0 + s * n.x * n.x * a, s * b, -s * n.x),
+    vec3<f32>(b, s + n.y * n.y * a, -n.y),
+    n);
+}
+
+/** Cosine weighted direction in the hemisphere around the normal; the weight cancels the Lambert cosine. */
+fn cosineDirection(normal: vec3<f32>, u: vec2<f32>) -> vec3<f32> {
+  let radius = sqrt(u.x);
+  let angle = 2.0 * PI * u.y;
+  let local = vec3<f32>(radius * cos(angle), radius * sin(angle), sqrt(max(0.0, 1.0 - u.x)));
+
+  return normalize(orthonormalBasis(normal) * local);
+}
+
+/** 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);
+
+  return normalize(cross(triangleVertex(triangle, 1u) - a, triangleVertex(triangle, 2u) - a));
+}
+`;

package/src/wgsl/shaderSupport.wgsl.ts

@@ -0,0 +1,119 @@
+/**
+ * What a translated shader reads from the kernel: its inputs at a hit, its texture calls and its varyings. The
+ * programs themselves are generated per scene by shaderProgram.ts and come right after this.
+ */
+export const SHADER_SUPPORT_WGSL = /* wgsl */ `
+/** Everything a fragment shader can ask about the point it runs at. */
+struct ShaderInput {
+  // Where the material's uniform values start in the texture buffer.
+  data: u32,
+  material: u32,
+  triangle: u32,
+  frontFacing: bool,
+  bary: vec2<f32>,
+  // The barycentrics the pixel to the right and the pixel above would have found on the same plane.
+  baryDx: vec2<f32>,
+  baryDy: vec2<f32>,
+  // GL window coordinates: x right, y up from the bottom, z the depth, w the reciprocal of clip w.
+  fragCoord: vec4<f32>,
+  pointCoord: vec2<f32>,
+  // A sky's view direction.
+  direction: vec3<f32>,
+  // A built-in material's state before lighting, for its hooks, in Three's view space.
+  diffuseColor: vec4<f32>,
+  normal: vec3<f32>,
+  roughness: f32,
+  metalness: f32,
+  emissive: vec3<f32>,
+  viewPosition: vec3<f32>,
+  geometryNormal: vec3<f32>,
+  uv: vec2<f32>,
+  // What gl_FragColor holds when a hook after <opaque_fragment> starts.
+  fragColor: vec4<f32>,
+};
+
+struct ShaderOutput {
+  color: vec4<f32>,
+  discarded: bool,
+  diffuseColor: vec4<f32>,
+  normal: vec3<f32>,
+  roughness: f32,
+  metalness: f32,
+  emissive: vec3<f32>,
+};
+
+/** The output of a shader that changed nothing, which is what a hook that does not touch a value leaves. */
+fn noShaderOutput(input: ShaderInput) -> ShaderOutput {
+  var output: ShaderOutput;
+  output.color = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  output.discarded = false;
+  output.diffuseColor = input.diffuseColor;
+  output.normal = input.normal;
+  output.roughness = input.roughness;
+  output.metalness = input.metalness;
+  output.emissive = input.emissive;
+
+  return output;
+}
+
+/** texture2D: an unbound sampler reads black, as WebGL's does. */
+fn shaderSample2D(index: u32, uv: vec2<f32>) -> vec4<f32> {
+  if (index == NO_TEXTURE) {
+    return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  }
+
+  return sampleTextureRaw(index, uv);
+}
+
+/** textureCube: the snapshot hands a cube map over unwrapped, mirrored the way Three samples a cube texture. */
+fn shaderSampleCube(index: u32, direction: vec3<f32>) -> vec4<f32> {
+  if (index == NO_TEXTURE) {
+    return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  }
+
+  return sampleEquirect(index, direction);
+}
+
+fn shaderTexelFetch(index: u32, texel: vec2<i32>) -> vec4<f32> {
+  if (index == NO_TEXTURE) {
+    return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  }
+
+  let info = textureInfo(index);
+  let size = vec2<i32>(info.size);
+  let at = clamp(texel, vec2<i32>(0), max(size - vec2<i32>(1), vec2<i32>(0)));
+  // texelFetch reads rows as GL stores them; a texture flipped on upload is flipped back here.
+  let row = select(at.y, size.y - 1 - at.y, (info.flags & 8u) != 0u);
+
+  return readTexel(info, at.x, row);
+}
+
+fn shaderTextureSize(index: u32) -> vec2<i32> {
+  if (index == NO_TEXTURE) {
+    return vec2<i32>(0);
+  }
+
+  return vec2<i32>(textureInfo(index).size);
+}
+
+/** Where a triangle's varyings start (x) and how many floats one corner has (y). */
+fn shaderVaryingAddress(material: u32, triangle: u32) -> vec2<u32> {
+  let stride = materials[material].varyingStride;
+  let local = triangle - materials[material].firstTriangle;
+
+  return vec2<u32>(frame.varyingOffset + materials[material].varyingBase + local * 3u * stride, stride);
+}
+
+/** One component of a varying at a point: interpolated, or the last vertex's for a flat one, as GL takes it. */
+fn shaderVarying(at: vec2<u32>, component: u32, bary: vec2<f32>, flat: bool) -> f32 {
+  let v0 = attributes[at.x + component];
+  let v1 = attributes[at.x + at.y + component];
+  let v2 = attributes[at.x + 2u * at.y + component];
+
+  if (flat) {
+    return v2;
+  }
+
+  return v0 * (1.0 - bary.x - bary.y) + v1 * bary.x + v2 * bary.y;
+}
+`;