@meimu/mutracer 0.1.4 → 0.2.0

package/lib/renderer/wgsl/jnlm.compute.js

@@ -0,0 +1,315 @@
+import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
+import { linearToSrgbDefine } from './compose.frag.wgsl.js';
+import { JNLM_DEFAULT_COLOR_SENSITIVITY, JNLM_DEFAULT_SHAPE, JNLM_ALBEDO_FLOOR, JNLM_ALBEDO_REGULARIZATION, JNLM_COVERAGE_BANDWIDTH, jnlmPassDilation } from '../jnlm.js';
+function guideBinding(guides, binding, name) {
+    return guides === 'textures'
+        ? `@group(0) @binding(${binding}) var ${name}: texture_2d<f32>;`
+        : `@group(0) @binding(${binding}) var<storage, read> ${name}: array<vec4f>;`;
+}
+function loadGuide(guides, name, position) {
+    return guides === 'textures' ? `textureLoad(${name}, ${position}, 0)` : `${name}[gv(${position})]`;
+}
+// Shared uniform packing also fixes sensitivity and dilation for native callers.
+export function packJNLMParameters(width, height, strength, pass) {
+    const bytes = new ArrayBuffer(16);
+    new Uint32Array(bytes, 0, 2).set([width, height]);
+    new Float32Array(bytes, 8, 2).set([
+        JNLM_DEFAULT_COLOR_SENSITIVITY * Math.max(strength, 1e-3), jnlmPassDilation(pass)
+    ]);
+    return bytes;
+}
+export const JNLM_WORKGROUP_SIZE = 8;
+const paramsWGSL = /* wgsl */ `
+struct JNLMParams {
+size: vec2u,
+colorSensitivity: f32,
+
+dilation: f32,
+}
+@group(0) @binding(0) var<uniform> params: JNLMParams;
+`;
+/**
+ * Pass 1: the guide mean and the variance of that mean from the accumulated
+ * moments. Ray buffers are stored bottom-up; guides use texture rows.
+ */
+export const jnlmGuideWGSL = /* wgsl */ `
+${paramsWGSL}
+${shadowCatcherAccumulationWGSL}
+@group(0) @binding(1) var<storage, read> accumulation: array<ShadowCatcherAccumulation>;
+@group(0) @binding(2) var<storage, read> normalBuffer: array<vec4f>;
+@group(0) @binding(3) var<storage, read_write> rawGuide: array<vec2f>;
+
+@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+let size = params.size;
+if (id.x >= size.x || id.y >= size.y) { return; }
+let qE = id.x + (size.y - 1u - id.y) * size.x;
+let n = normalBuffer[qE].a;
+let moments = accumulation[qE].moments;
+let mean = moments.x / max(n, 1.0);
+
+var variance = -1.0;
+if (n >= 2.0) {
+variance = max(moments.y - n * mean * mean, 0.0) / (n * (n - 1.0));
+}
+rawGuide[id.x + id.y * size.x] = vec2f(mean, variance);
+}
+`;
+/**
+ * Pass 2: smooth the noisy per-pixel variance over 3 x 3 pixels. Pixels with
+ * a single sample take the spatial variance of their neighborhood instead.
+ */
+export const jnlmVarianceWGSL = /* wgsl */ `
+${paramsWGSL}
+@group(0) @binding(1) var<storage, read> rawGuide: array<vec2f>;
+@group(0) @binding(2) var<storage, read_write> guide: array<vec2f>;
+
+@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+let size = params.size;
+if (id.x >= size.x || id.y >= size.y) { return; }
+let center = rawGuide[id.x + id.y * size.x];
+var mf = 0.0;
+var jx = 0.0;
+var nW = 0.0;
+var jp = 0.0;
+for (var dy = -1; dy <= 1; dy++) {
+for (var dx = -1; dx <= 1; dx++) {
+let q = clamp(vec2i(id.xy) + vec2i(dx, dy), vec2i(0), vec2i(size) - 1);
+let value = rawGuide[u32(q.x) + u32(q.y) * size.x];
+nW += value.x;
+jp += value.x * value.x;
+if (value.y >= 0.0) {
+mf += value.y;
+jx += 1.0;
+}
+}
+}
+var variance: f32;
+if (center.y >= 0.0) {
+variance = mf / jx;
+} else {
+let me = nW / 9.0;
+variance = max(jp / 9.0 - me * me, 0.0) * 9.0 / 8.0;
+}
+guide[id.x + id.y * size.x] = vec2f(center.x, variance);
+}
+`;
+/** Copies the composed image into the filter's color buffer. */
+export function createJNLMLoadColorWGSL(guides = 'textures') {
+    return /* wgsl */ `
+${paramsWGSL}
+@group(0) @binding(1) var colorTex: texture_2d<f32>;
+@group(0) @binding(2) var<storage, read_write> outColor: array<vec4f>;
+${guides === 'buffers' ? `${shadowCatcherAccumulationWGSL}
+@group(0) @binding(3) var<storage, read> normalAccumulation: array<vec4f>;
+@group(0) @binding(4) var<storage, read_write> normal: array<vec4f>;
+@group(0) @binding(5) var<storage, read> shadowAccumulation: array<ShadowCatcherAccumulation>;
+@group(0) @binding(6) var<storage, read_write> shadow: array<vec4f>;
+@group(0) @binding(7) var albedoTex: texture_2d<f32>;
+@group(0) @binding(8) var<storage, read_write> albedo: array<vec4f>;` : ''}
+
+@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+if (id.x >= params.size.x || id.y >= params.size.y) { return; }
+outColor[id.x + id.y * params.size.x] = textureLoad(colorTex, vec2i(id.xy), 0);
+${guides === 'buffers' ? `  let index = id.x + id.y * params.size.x;
+let qE = id.x + (params.size.y - 1u - id.y) * params.size.x;
+let n = normalAccumulation[qE];
+let samples = max(n.a, 1.0);
+normal[index] = vec4f(n.rgb / samples * 0.5 + 0.5, select(0.0, 1.0, dot(n.rgb, n.rgb) > 0.1));
+shadow[index] = shadowAccumulation[qE].mask / samples;
+albedo[index] = textureLoad(albedoTex, vec2i(id.xy), 0);` : ''}
+}
+`;
+}
+export const jnlmLoadColorWGSL = createJNLMLoadColorWGSL();
+/**
+ * Pass 3: the joint NL-means filter of the composed image. It also filters
+ * the guide with the same weights, with the variance of the weighted mean,
+ * for a following pass. The albedo regression corrects color only, keeping
+ * uncertain fitted texture responses out of the matching guide.
+ */
+export function createJNLMFilterWGSL({ searchRadius, patchRadius, albedoBandwidth, normalBandwidth } = JNLM_DEFAULT_SHAPE, guides = 'textures') {
+    const patchSize = (2 * patchRadius + 1) ** 2;
+    return /* wgsl */ `
+${paramsWGSL}
+@group(0) @binding(1) var<storage, read> guide: array<vec2f>;
+@group(0) @binding(2) var<storage, read> color: array<vec4f>;
+${guideBinding(guides, 3, 'albedoTex')}
+${guideBinding(guides, 4, 'normalTex')}
+@group(0) @binding(5) var<storage, read_write> outColor: array<vec4f>;
+@group(0) @binding(6) var<storage, read_write> outGuide: array<vec2f>;
+${guideBinding(guides, 7, 'shadowCatcherTex')}
+
+const SEARCH_RADIUS = ${searchRadius};
+const PATCH_RADIUS = ${patchRadius};
+const PATCH_SIZE = ${patchSize};
+
+const VARIANCE_CANCELLATION = 1.0;
+
+const INV_ALBEDO_BANDWIDTH2 = ${(1 / albedoBandwidth ** 2).toFixed(6)};
+const INV_COVERAGE_BANDWIDTH2 = ${(1 / JNLM_COVERAGE_BANDWIDTH ** 2).toFixed(6)};
+const INV_NORMAL_BANDWIDTH2 = ${(1 / normalBandwidth ** 2).toFixed(6)};
+
+
+const CENTER_WEIGHT_MIN = 0.01;
+
+fn gv(p: vec2i) -> u32 {
+let q = clamp(p, vec2i(0), vec2i(params.size) - 1);
+return u32(q.x) + u32(q.y) * params.size.x;
+}
+
+fn mi(q: vec2i, bC: vec4f, hg: vec3f) -> f32 {
+let albedo = ${loadGuide(guides, 'albedoTex', 'q')};
+
+
+let qd = max((albedo.rgb + bC.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));
+let lN = (albedo.rgb - bC.rgb) / qd;
+let jk = albedo.a - bC.a;
+let lX = ${loadGuide(guides, 'normalTex', 'q')}.rgb - hg;
+return max(
+dot(lN, lN) * INV_ALBEDO_BANDWIDTH2
++ jk * jk * INV_COVERAGE_BANDWIDTH2,
+dot(lX, lX) * INV_NORMAL_BANDWIDTH2
+);
+}
+
+fn premultiplied(c: vec4f) -> vec4f {
+return vec4f(c.rgb * c.a, c.a);
+}
+
+@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+let size = vec2i(params.size);
+let p = vec2i(id.xy);
+if (p.x >= size.x || p.y >= size.y) { return; }
+let step = i32(params.dilation);
+let bC = ${loadGuide(guides, 'albedoTex', 'p')};
+let fR = ${loadGuide(guides, 'normalTex', 'p')};
+let hg = fR.rgb;
+let index = gv(p);
+
+
+if (fR.a <= 0.0 && ${loadGuide(guides, 'shadowCatcherTex', 'p')}.r <= 0.0) {
+outColor[index] = color[index];
+outGuide[index] = guide[index];
+return;
+}
+
+var lP: array<vec2f, PATCH_SIZE>;
+var k = 0;
+for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
+for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
+lP[k] = guide[gv(p + vec2i(dx, dy) * step)];
+k++;
+}
+}
+let k2 = params.colorSensitivity * params.colorSensitivity;
+
+var sum = vec4f(0.0);
+let hk = max(bC.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));
+var ng = vec3f(0.0);
+var gN = vec3f(0.0);
+var hG = vec3f(0.0);
+var qp = 0.0;
+var gP = 0.0;
+var oP = 0.0;
+var lt = 0.0;
+for (var sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
+for (var sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
+let q = p + vec2i(sx, sy) * step;
+if (
+(sx == 0 && sy == 0) ||
+q.x < 0 || q.y < 0 || q.x >= size.x || q.y >= size.y
+) { continue; }
+
+let features = mi(q, bC, hg);
+if (features > 16.0) { continue; }
+
+var gk = 0.0;
+k = 0;
+for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
+for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
+let a = lP[k];
+let b = guide[gv(q + vec2i(dx, dy) * step)];
+let rZ = a.x - b.x;
+gk += (rZ * rZ
+- VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
+/ (1e-10 + k2 * (a.y + b.y));
+k++;
+}
+}
+gk /= f32(PATCH_SIZE);
+
+let weight = exp(-max(max(gk, 0.0), features));
+let index = gv(q);
+let c = color[index];
+let g = guide[index];
+
+let a = (${loadGuide(guides, 'albedoTex', 'q')}.rgb - bC.rgb) / hk;
+let value = premultiplied(c);
+sum += value * weight;
+ng += a * weight;
+gN += a * a * weight;
+hG += a * value.rgb * weight;
+qp += g.x * weight;
+gP += g.y * weight * weight;
+oP += weight;
+lt = max(lt, weight);
+}
+}
+
+
+
+let center = color[index];
+let lO = guide[index];
+let dR = max(lt, CENTER_WEIGHT_MIN);
+let totalWeight = oP + dR;
+let vj = premultiplied(center);
+let mean = (sum + vj * dR) / totalWeight;
+
+
+let eI = ng / totalWeight;
+let mj = max(gN / totalWeight - eI * eI, vec3f(0.0));
+let rv = hG / totalWeight - eI * mean.rgb;
+
+
+
+let rI = bC.rgb + eI * hk;
+let po = mean.rgb * hk / max(rI, vec3f(${JNLM_ALBEDO_FLOOR}));
+let xg = clamp(rv / (mj + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), po);
+let sD = mean.rgb - xg * eI;
+let filtered = vec4f(max(sD, vec3f(0.0)), max(mean.a, 0.0));
+let rgb = select(
+center.rgb,
+filtered.rgb / max(filtered.a, 1e-6),
+filtered.a > 1e-6
+);
+outColor[index] = vec4f(rgb, filtered.a);
+outGuide[index] = vec2f(
+(qp + lO.x * dR) / totalWeight,
+(gP + lO.y * dR * dR)
+/ (totalWeight * totalWeight)
+);
+}
+`;
+}
+// Compute presentation for hosts that consume the filtered buffer directly.
+// Use the same sRGB transfer as browser display composition.
+export const jnlmEncodeWGSL = /* wgsl */ `
+struct OutputParams { size: vec2u, premultiply: u32, reserved: u32 }
+@group(0) @binding(0) var<uniform> params: OutputParams;
+@group(0) @binding(1) var<storage, read> color: array<vec4f>;
+@group(0) @binding(2) var output: texture_storage_2d<rgba8unorm, write>;
+${linearToSrgbDefine}
+@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= params.size)) { return; }
+let c = color[id.y * params.size.x + id.x];
+var rgb = linearToSrgb(c.rgb);
+if (params.premultiply != 0u) { rgb *= c.a; }
+textureStore(output, id.xy, vec4f(rgb, c.a));
+}
+`;
+//# sourceMappingURL=jnlm.compute.js.map

package/lib/renderer/wgsl/jnlm.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jnlm.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/jnlm.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';\nimport {linearToSrgbDefine} from './compose.frag.wgsl.js';\nimport {\n  JNLM_DEFAULT_COLOR_SENSITIVITY, JNLM_DEFAULT_SHAPE, JNLM_ALBEDO_FLOOR,\n  JNLM_ALBEDO_REGULARIZATION, JNLM_COVERAGE_BANDWIDTH, jnlmPassDilation,\n  type JNLMFilterShape\n} from '../jnlm.js';\n\n// Web textures and native normalized guide buffers use the same filter body.\nexport type JNLMGuideBindings = 'textures' | 'buffers';\nfunction guideBinding(guides: JNLMGuideBindings, binding: number, name: string): string {\n  return guides === 'textures'\n    ? `@group(0) @binding(${binding}) var ${name}: texture_2d<f32>;`\n    : `@group(0) @binding(${binding}) var<storage, read> ${name}: array<vec4f>;`;\n}\nfunction loadGuide(guides: JNLMGuideBindings, name: string, position: string): string {\n  return guides === 'textures' ? `textureLoad(${name}, ${position}, 0)` : `${name}[pixelIndex(${position})]`;\n}\n\n// Shared uniform packing also fixes sensitivity and dilation for native callers.\nexport function packJNLMParameters(width: number, height: number, strength: number, pass: number): ArrayBuffer {\n  const bytes = new ArrayBuffer(16);\n  new Uint32Array(bytes, 0, 2).set([width, height]);\n  new Float32Array(bytes, 8, 2).set([\n    JNLM_DEFAULT_COLOR_SENSITIVITY * Math.max(strength, 1e-3), jnlmPassDilation(pass)\n  ]);\n  return bytes;\n}\n\nexport const JNLM_WORKGROUP_SIZE = 8;\n\nconst paramsWGSL = /* wgsl */ `\nstruct JNLMParams {\n  size: vec2u,\n  colorSensitivity: f32,\n  // Pixel spacing of the search window and patches in this pass.\n  dilation: f32,\n}\n@group(0) @binding(0) var<uniform> params: JNLMParams;\n`;\n\n/**\n * Pass 1: the guide mean and the variance of that mean from the accumulated\n * moments. Ray buffers are stored bottom-up; guides use texture rows.\n */\nexport const jnlmGuideWGSL = /* wgsl */ `\n${paramsWGSL}\n${shadowCatcherAccumulationWGSL}\n@group(0) @binding(1) var<storage, read> accumulation: array<ShadowCatcherAccumulation>;\n@group(0) @binding(2) var<storage, read> normalBuffer: array<vec4f>;\n@group(0) @binding(3) var<storage, read_write> rawGuide: array<vec2f>;\n\n@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  let size = params.size;\n  if (id.x >= size.x || id.y >= size.y) { return; }\n  let rayIndex = id.x + (size.y - 1u - id.y) * size.x;\n  let n = normalBuffer[rayIndex].a;\n  let moments = accumulation[rayIndex].moments;\n  let mean = moments.x / max(n, 1.0);\n  // Variance of the mean, or -1 when one sample cannot estimate it.\n  var variance = -1.0;\n  if (n >= 2.0) {\n    variance = max(moments.y - n * mean * mean, 0.0) / (n * (n - 1.0));\n  }\n  rawGuide[id.x + id.y * size.x] = vec2f(mean, variance);\n}\n`;\n\n/**\n * Pass 2: smooth the noisy per-pixel variance over 3 x 3 pixels. Pixels with\n * a single sample take the spatial variance of their neighborhood instead.\n */\nexport const jnlmVarianceWGSL = /* wgsl */ `\n${paramsWGSL}\n@group(0) @binding(1) var<storage, read> rawGuide: array<vec2f>;\n@group(0) @binding(2) var<storage, read_write> guide: array<vec2f>;\n\n@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  let size = params.size;\n  if (id.x >= size.x || id.y >= size.y) { return; }\n  let center = rawGuide[id.x + id.y * size.x];\n  var varianceSum = 0.0;\n  var varianceCount = 0.0;\n  var meanSum = 0.0;\n  var meanSquareSum = 0.0;\n  for (var dy = -1; dy <= 1; dy++) {\n    for (var dx = -1; dx <= 1; dx++) {\n      let q = clamp(vec2i(id.xy) + vec2i(dx, dy), vec2i(0), vec2i(size) - 1);\n      let value = rawGuide[u32(q.x) + u32(q.y) * size.x];\n      meanSum += value.x;\n      meanSquareSum += value.x * value.x;\n      if (value.y >= 0.0) {\n        varianceSum += value.y;\n        varianceCount += 1.0;\n      }\n    }\n  }\n  var variance: f32;\n  if (center.y >= 0.0) {\n    variance = varianceSum / varianceCount;\n  } else {\n    let spatialMean = meanSum / 9.0;\n    variance = max(meanSquareSum / 9.0 - spatialMean * spatialMean, 0.0) * 9.0 / 8.0;\n  }\n  guide[id.x + id.y * size.x] = vec2f(center.x, variance);\n}\n`;\n\n/** Copies the composed image into the filter's color buffer. */\nexport function createJNLMLoadColorWGSL(guides: JNLMGuideBindings = 'textures'): string {\n  return /* wgsl */ `\n${paramsWGSL}\n@group(0) @binding(1) var colorTex: texture_2d<f32>;\n@group(0) @binding(2) var<storage, read_write> outColor: array<vec4f>;\n${guides === 'buffers' ? `${shadowCatcherAccumulationWGSL}\n@group(0) @binding(3) var<storage, read> normalAccumulation: array<vec4f>;\n@group(0) @binding(4) var<storage, read_write> normal: array<vec4f>;\n@group(0) @binding(5) var<storage, read> shadowAccumulation: array<ShadowCatcherAccumulation>;\n@group(0) @binding(6) var<storage, read_write> shadow: array<vec4f>;\n@group(0) @binding(7) var albedoTex: texture_2d<f32>;\n@group(0) @binding(8) var<storage, read_write> albedo: array<vec4f>;` : ''}\n\n@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  if (id.x >= params.size.x || id.y >= params.size.y) { return; }\n  outColor[id.x + id.y * params.size.x] = textureLoad(colorTex, vec2i(id.xy), 0);\n${guides === 'buffers' ? `  let index = id.x + id.y * params.size.x;\n  let rayIndex = id.x + (params.size.y - 1u - id.y) * params.size.x;\n  let n = normalAccumulation[rayIndex];\n  let samples = max(n.a, 1.0);\n  normal[index] = vec4f(n.rgb / samples * 0.5 + 0.5, select(0.0, 1.0, dot(n.rgb, n.rgb) > 0.1));\n  shadow[index] = shadowAccumulation[rayIndex].mask / samples;\n  albedo[index] = textureLoad(albedoTex, vec2i(id.xy), 0);` : ''}\n}\n`;\n}\nexport const jnlmLoadColorWGSL = createJNLMLoadColorWGSL();\n\n/**\n * Pass 3: the joint NL-means filter of the composed image. It also filters\n * the guide with the same weights, with the variance of the weighted mean,\n * for a following pass. The albedo regression corrects color only, keeping\n * uncertain fitted texture responses out of the matching guide.\n */\nexport function createJNLMFilterWGSL({\n  searchRadius, patchRadius, albedoBandwidth, normalBandwidth\n}: JNLMFilterShape = JNLM_DEFAULT_SHAPE, guides: JNLMGuideBindings = 'textures') {\n  const patchSize = (2 * patchRadius + 1) ** 2;\n  return /* wgsl */ `\n${paramsWGSL}\n@group(0) @binding(1) var<storage, read> guide: array<vec2f>;\n@group(0) @binding(2) var<storage, read> color: array<vec4f>;\n${guideBinding(guides, 3, 'albedoTex')}\n${guideBinding(guides, 4, 'normalTex')}\n@group(0) @binding(5) var<storage, read_write> outColor: array<vec4f>;\n@group(0) @binding(6) var<storage, read_write> outGuide: array<vec2f>;\n${guideBinding(guides, 7, 'shadowCatcherTex')}\n\nconst SEARCH_RADIUS = ${searchRadius};\nconst PATCH_RADIUS = ${patchRadius};\nconst PATCH_SIZE = ${patchSize};\n// Variance cancellation strength alpha of the paper.\nconst VARIANCE_CANCELLATION = 1.0;\n// Inverse squared feature bandwidths. Normals are encoded as n * 0.5 + 0.5.\nconst INV_ALBEDO_BANDWIDTH2 = ${(1 / albedoBandwidth ** 2).toFixed(6)};\nconst INV_COVERAGE_BANDWIDTH2 = ${(1 / JNLM_COVERAGE_BANDWIDTH ** 2).toFixed(6)};\nconst INV_NORMAL_BANDWIDTH2 = ${(1 / normalBandwidth ** 2).toFixed(6)};\n// Lower bound of the center weight, so a pixel unlike all of its neighbors\n// (a thin highlight) is kept rather than replaced by them.\nconst CENTER_WEIGHT_MIN = 0.01;\n\nfn pixelIndex(p: vec2i) -> u32 {\n  let q = clamp(p, vec2i(0), vec2i(params.size) - 1);\n  return u32(q.x) + u32(q.y) * params.size.x;\n}\n\nfn featureDistance(q: vec2i, centerAlbedo: vec4f, centerNormal: vec3f) -> f32 {\n  let albedo = ${loadGuide(guides, 'albedoTex', 'q')};\n  // Absolute differences in linear albedo erase low-contrast dark textures.\n  // Measure RGB contrast relative to both pixels; keep coverage absolute.\n  let albedoScale = max((albedo.rgb + centerAlbedo.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));\n  let albedoDelta = (albedo.rgb - centerAlbedo.rgb) / albedoScale;\n  let coverageDelta = albedo.a - centerAlbedo.a;\n  let normalDelta = ${loadGuide(guides, 'normalTex', 'q')}.rgb - centerNormal;\n  return max(\n    dot(albedoDelta, albedoDelta) * INV_ALBEDO_BANDWIDTH2\n      + coverageDelta * coverageDelta * INV_COVERAGE_BANDWIDTH2,\n    dot(normalDelta, normalDelta) * INV_NORMAL_BANDWIDTH2\n  );\n}\n\nfn premultiplied(c: vec4f) -> vec4f {\n  return vec4f(c.rgb * c.a, c.a);\n}\n\n@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  let size = vec2i(params.size);\n  let p = vec2i(id.xy);\n  if (p.x >= size.x || p.y >= size.y) { return; }\n  let step = i32(params.dilation);\n  let centerAlbedo = ${loadGuide(guides, 'albedoTex', 'p')};\n  let centerNormalTexel = ${loadGuide(guides, 'normalTex', 'p')};\n  let centerNormal = centerNormalTexel.rgb;\n  let index = pixelIndex(p);\n  // Primary misses show the background directly. It has no features that\n  // protect its detail and no noise beyond antialiasing, so keep it.\n  if (centerNormalTexel.a <= 0.0 && ${loadGuide(guides, 'shadowCatcherTex', 'p')}.r <= 0.0) {\n    outColor[index] = color[index];\n    outGuide[index] = guide[index];\n    return;\n  }\n\n  var centerPatch: array<vec2f, PATCH_SIZE>;\n  var k = 0;\n  for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {\n    for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {\n      centerPatch[k] = guide[pixelIndex(p + vec2i(dx, dy) * step)];\n      k++;\n    }\n  }\n  let k2 = params.colorSensitivity * params.colorSensitivity;\n\n  var sum = vec4f(0.0);\n  let featureScale = max(centerAlbedo.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));\n  var featureSum = vec3f(0.0);\n  var featureSquareSum = vec3f(0.0);\n  var featureColorSum = vec3f(0.0);\n  var guideSum = 0.0;\n  var guideVarianceSum = 0.0;\n  var weightSum = 0.0;\n  var maxWeight = 0.0;\n  for (var sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {\n    for (var sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {\n      let q = p + vec2i(sx, sy) * step;\n      if (\n        (sx == 0 && sy == 0) ||\n        q.x < 0 || q.y < 0 || q.x >= size.x || q.y >= size.y\n      ) { continue; }\n\n      let features = featureDistance(q, centerAlbedo, centerNormal);\n      if (features > 16.0) { continue; }\n\n      var colorDistance = 0.0;\n      k = 0;\n      for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {\n        for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {\n          let a = centerPatch[k];\n          let b = guide[pixelIndex(q + vec2i(dx, dy) * step)];\n          let delta = a.x - b.x;\n          colorDistance += (delta * delta\n              - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))\n            / (1e-10 + k2 * (a.y + b.y));\n          k++;\n        }\n      }\n      colorDistance /= f32(PATCH_SIZE);\n\n      let weight = exp(-max(max(colorDistance, 0.0), features));\n      let index = pixelIndex(q);\n      let c = color[index];\n      let g = guide[index];\n      // Filter premultiplied color so coverage and color stay consistent.\n      let a = (${loadGuide(guides, 'albedoTex', 'q')}.rgb - centerAlbedo.rgb) / featureScale;\n      let value = premultiplied(c);\n      sum += value * weight;\n      featureSum += a * weight;\n      featureSquareSum += a * a * weight;\n      featureColorSum += a * value.rgb * weight;\n      guideSum += g.x * weight;\n      guideVarianceSum += g.y * weight * weight;\n      weightSum += weight;\n      maxWeight = max(maxWeight, weight);\n    }\n  }\n\n  // Weight the center like its most similar neighbor (Buades et al. 2005)\n  // instead of 1, so isolated outliers are not kept unfiltered.\n  let center = color[index];\n  let centerGuide = guide[index];\n  let centerWeight = max(maxWeight, CENTER_WEIGHT_MIN);\n  let totalWeight = weightSum + centerWeight;\n  let centerValue = premultiplied(center);\n  let mean = (sum + centerValue * centerWeight) / totalWeight;\n  // Fit each color channel against relative albedo with the same JNLM weights.\n  // Centering at this pixel avoids cancellation when the feature is constant.\n  let meanFeature = featureSum / totalWeight;\n  let featureVariance = max(featureSquareSum / totalWeight - meanFeature * meanFeature, vec3f(0.0));\n  let covariance = featureColorSum / totalWeight - meanFeature * mean.rgb;\n  // A 1% contrast ridge stabilizes flat guides. Bound the response between no\n  // texture dependence and multiplicative albedo modulation; specular color\n  // with an unrelated albedo falls back to the weighted mean.\n  let meanAlbedo = centerAlbedo.rgb + meanFeature * featureScale;\n  let maximumSlope = mean.rgb * featureScale / max(meanAlbedo, vec3f(${JNLM_ALBEDO_FLOOR}));\n  let slope = clamp(covariance / (featureVariance + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), maximumSlope);\n  let corrected = mean.rgb - slope * meanFeature;\n  let filtered = vec4f(max(corrected, vec3f(0.0)), max(mean.a, 0.0));\n  let rgb = select(\n    center.rgb,\n    filtered.rgb / max(filtered.a, 1e-6),\n    filtered.a > 1e-6\n  );\n  outColor[index] = vec4f(rgb, filtered.a);\n  outGuide[index] = vec2f(\n    (guideSum + centerGuide.x * centerWeight) / totalWeight,\n    (guideVarianceSum + centerGuide.y * centerWeight * centerWeight)\n      / (totalWeight * totalWeight)\n  );\n}\n`;\n}\n\n// Compute presentation for hosts that consume the filtered buffer directly.\n// Use the same sRGB transfer as browser display composition.\nexport const jnlmEncodeWGSL = /* wgsl */ `\nstruct OutputParams { size: vec2u, premultiply: u32, reserved: u32 }\n@group(0) @binding(0) var<uniform> params: OutputParams;\n@group(0) @binding(1) var<storage, read> color: array<vec4f>;\n@group(0) @binding(2) var output: texture_storage_2d<rgba8unorm, write>;\n${linearToSrgbDefine}\n@compute @workgroup_size(${JNLM_WORKGROUP_SIZE}, ${JNLM_WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= params.size)) { return; }\n  let c = color[id.y * params.size.x + id.x];\n  var rgb = linearToSrgb(c.rgb);\n  if (params.premultiply != 0u) { rgb *= c.a; }\n  textureStore(output, id.xy, vec4f(rgb, c.a));\n}\n`;\n"]}

package/lib/renderer/wgsl/offlineAdaptive.compute.js

@@ -27,8 +27,8 @@ _padding: f32,
 const LUMINANCE = vec3f(0.2126, 0.7152, 0.0722);
 
 @compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) uq: vec3u) {
-let tile = uq.x;
+fn main(@builtin(global_invocation_id) vQ: vec3u) {
+let tile = vQ.x;
 let tileCount = params.columns * params.rows;
 if (tile >= tileCount) {
 return;
@@ -36,18 +36,18 @@ return;
 
 let tileX = tile % params.columns;
 let tileY = tile / params.columns;
-let ux = tileX * params.tileSize;
-let uy = tileY * params.tileSize;
-let wl = min(ux + params.tileSize, params.width);
-let wm = min(uy + params.tileSize, params.height);
-var mZ = 0.0;
-var je = 0.0;
+let vY = tileX * params.tileSize;
+let vZ = tileY * params.tileSize;
+let ye = min(vY + params.tileSize, params.width);
+let yf = min(vZ + params.tileSize, params.height);
+var nW = 0.0;
+var jB = 0.0;
 var count = 0u;
 
-for (var y = uy; y < wm; y++) {
-for (var x = ux; x < wl; x++) {
-let fP = y * params.width + x;
-let offset = fP * 4u;
+for (var y = vZ; y < yf; y++) {
+for (var x = vY; x < ye; x++) {
+let pixel = y * params.width + x;
+let offset = pixel * 4u;
 let samples = pilotMoments[offset + 3u];
 if (samples <= 0.0) {
 continue;
@@ -60,28 +60,28 @@ pilotColor[offset + 2u]
 ),
 LUMINANCE
 ) / samples;
-let tK = pilotMoments[offset] / samples;
-let pi = max(tK - mean * mean, 0.0);
-var variance = pi;
+let va = pilotMoments[offset] / samples;
+let qg = max(va - mean * mean, 0.0);
+var variance = qg;
 if (samples > 1.0) {
-variance = pi * samples / (samples - 1.0);
+variance = qg * samples / (samples - 1.0);
 }
-mZ += mean;
-je = max(je, variance);
+nW += mean;
+jB = max(jB, variance);
 count += 1u;
 }
 }
 
-let mean = mZ / f32(max(count, 1u));
-var oX = 0.0;
+let mean = nW / f32(max(count, 1u));
+var pT = 0.0;
 if (params.hasPrevious != 0u) {
-oX = previousVariance[tile];
+pT = previousVariance[tile];
 }
-let sj = max(je, oX);
-let tf = params.absoluteError + params.relativeError * abs(mean);
+let tu = max(jB, pT);
+let uD = params.absoluteError + params.relativeError * abs(mean);
 let required = ceil(
-params.confidence * params.confidence * sj /
-max(tf * tf, 1e-16)
+params.confidence * params.confidence * tu /
+max(uD * uD, 1e-16)
 );
 let targetSamples = u32(min(
 f32(params.maxSamples),
@@ -91,11 +91,11 @@ max(f32(params.minSamples), required)
 tileMeans[tile] = mean;
 
 
-tileVariances[tile] = je;
+tileVariances[tile] = jB;
 tileTargets[tile] = targetSamples;
 
-for (var y = uy; y < wm; y++) {
-for (var x = ux; x < wl; x++) {
+for (var y = vZ; y < yf; y++) {
+for (var x = vY; x < ye; x++) {
 textureStore(
 targetTexture,
 vec2i(i32(x), i32(y)),

package/lib/renderer/wgsl/oidnAuxiliary.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const oidnAuxiliaryDefine = "\nfn oidnEncodeAlbedo(value: vec3f) -> vec3f {\n  let linear = clamp(value, vec3f(0.0), vec3f(1.0));\n  return select(1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055,\n    12.92 * linear, linear <= vec3f(0.0031308));\n}\nfn oidnDecodeAlbedo(value: vec3f) -> vec3f {\n  let encoded = clamp(value, vec3f(0.0), vec3f(1.0));\n  return select(pow((encoded + 0.055) / 1.055, vec3f(2.4)),\n    encoded / 12.92, encoded <= vec3f(0.04045));\n}\nfn oidnSanitizeNormal(value: vec3f) -> vec3f {\n  return clamp(value, vec3f(0.0), vec3f(1.0));\n}\n";

package/lib/renderer/wgsl/oidnAuxiliary.wgsl.js

@@ -0,0 +1,17 @@
+// OIDN's LDR auxiliary networks use sRGB albedo and normals in [0,1].
+export const oidnAuxiliaryDefine = /* wgsl */ `
+fn sT(value: vec3f) -> vec3f {
+let linear = clamp(value, vec3f(0.0), vec3f(1.0));
+return select(1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055,
+12.92 * linear, linear <= vec3f(0.0031308));
+}
+fn sS(value: vec3f) -> vec3f {
+let encoded = clamp(value, vec3f(0.0), vec3f(1.0));
+return select(pow((encoded + 0.055) / 1.055, vec3f(2.4)),
+encoded / 12.92, encoded <= vec3f(0.04045));
+}
+fn rL(value: vec3f) -> vec3f {
+return clamp(value, vec3f(0.0), vec3f(1.0));
+}
+`;
+//# sourceMappingURL=oidnAuxiliary.wgsl.js.map

package/lib/renderer/wgsl/oidnAuxiliary.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oidnAuxiliary.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/oidnAuxiliary.wgsl.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;CAc7C,CAAC","sourcesContent":["// OIDN's LDR auxiliary networks use sRGB albedo and normals in [0,1].\nexport const oidnAuxiliaryDefine = /* wgsl */ `\nfn oidnEncodeAlbedo(value: vec3f) -> vec3f {\n  let linear = clamp(value, vec3f(0.0), vec3f(1.0));\n  return select(1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055,\n    12.92 * linear, linear <= vec3f(0.0031308));\n}\nfn oidnDecodeAlbedo(value: vec3f) -> vec3f {\n  let encoded = clamp(value, vec3f(0.0), vec3f(1.0));\n  return select(pow((encoded + 0.055) / 1.055, vec3f(2.4)),\n    encoded / 12.92, encoded <= vec3f(0.04045));\n}\nfn oidnSanitizeNormal(value: vec3f) -> vec3f {\n  return clamp(value, vec3f(0.0), vec3f(1.0));\n}\n`;\n"]}

package/lib/renderer/wgsl/proceduralSky.compute.d.ts

@@ -0,0 +1 @@
+export declare const proceduralSkyWGSL: string;

package/lib/renderer/wgsl/proceduralSky.compute.js

@@ -0,0 +1,198 @@
+import { TURBIDITY, GROUND_ALBEDO, ILLUMINANCE, REFERENCE_ILLUMINANCE } from '../skyModel.js';
+// Same atmosphere, quadrature and pass order as WebGLSkyBaker. Distances in km.
+export const proceduralSkyWGSL = /* wgsl */ `
+struct Params { sun: vec4f, sunWorld: vec4f, size: vec4f, scale: vec4f, ambient: vec4f }
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var transmittanceTable: texture_2d<f32>;
+@group(0) @binding(2) var multipleTable: texture_2d<f32>;
+@group(0) @binding(3) var skyTable: texture_2d<f32>;
+@group(0) @binding(4) var irradianceTable: texture_2d<f32>;
+@group(0) @binding(5) var output: texture_storage_2d<rgba32float, write>;
+const PI = 3.14159265358979;
+const R_GROUND = 6360.0;
+const R_TOP = 6460.0;
+const CAMERA_ALTITUDE = 0.2;
+const RAYLEIGH = vec3f(5.802e-3, 13.558e-3, 33.1e-3);
+const MIE_SCATTERING = 3.996e-3;
+const MIE_EXTINCTION = 4.44e-3;
+const MIE_G = 0.8;
+const OZONE = vec3f(0.65e-3, 1.881e-3, 0.085e-3);
+const ALBEDO = vec3f(${GROUND_ALBEDO.join(', ')});
+const T_SIZE = vec2u(256, 64);
+const MS_ALTITUDES = 32u;
+const SV_SIZE = vec2u(96, 192);
+
+fn br(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }
+fn np(r: f32, mu: f32) -> bool { return mu < 0.0 && br(r, mu, R_GROUND) >= 0.0; }
+fn ll(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(br(r, mu, R_GROUND), 0.0)), 0.0); }
+fn jm(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(br(r, mu, R_TOP), 0.0)), 0.0); }
+fn oz(r: f32) -> vec3f {
+let h = max(r - R_GROUND, 0.0);
+return vec3f(exp(-h / 8.0), exp(-h / 1.2) * ${TURBIDITY}, max(0.0, 1.0 - abs(h - 25.0) / 15.0));
+}
+fn extinction(d: vec3f) -> vec3f { return RAYLEIGH * d.x + MIE_EXTINCTION * d.y + OZONE * d.z; }
+fn mP(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }
+fn hR(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }
+fn fh(table: texture_2d<f32>, p: vec2f) -> vec3f {
+let size = vec2i(textureDimensions(table));
+let q = clamp(p, vec2f(0.0), vec2f(size - 1));
+let i = min(vec2i(floor(q)), max(size - 2, vec2i(0)));
+let f = clamp(q - vec2f(i), vec2f(0.0), vec2f(1.0));
+let j = min(i + 1, size - 1);
+let a = textureLoad(table, i, 0).rgb;
+let b = textureLoad(table, vec2i(j.x, i.y), 0).rgb;
+let c = textureLoad(table, vec2i(i.x, j.y), 0).rgb;
+let d = textureLoad(table, j, 0).rgb;
+return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+fn fO(r: f32, mu: f32) -> vec3f {
+return fh(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), hR(r - R_GROUND) * f32(T_SIZE.y - 1u)));
+}
+fn mW(nu: f32) -> f32 {
+let g2 = MIE_G * MIE_G;
+return 3.0 / (8.0 * PI) * ((1.0 - g2) * (1.0 + nu * nu)) / ((2.0 + g2) * pow(1.0 + g2 - 2.0 * MIE_G * nu, 1.5));
+}
+struct xJ { radiance: vec3f, throughput: vec3f }
+fn vt(origin: vec3f, dir: vec3f, steps: u32, full: bool, uw: vec3f) -> xJ {
+let r = length(origin);
+let mu = dot(origin, dir) / r;
+let ground = np(r, mu);
+var len = jm(r, mu);
+if (ground) { len = ll(r, mu); }
+let nu = dot(dir, params.sun.xyz);
+var jv = 1.0 / (4.0 * PI);
+var sn = jv;
+if (full) { jv = 3.0 / (16.0 * PI) * (1.0 + nu * nu); sn = mW(nu); }
+var result = xJ(vec3f(0.0), vec3f(0.0));
+var view = vec3f(1.0);
+var previous = 0.0;
+for (var i = 0u; i < steps; i++) {
+let s = f32(i + 1u) / f32(steps);
+let next = len * s * s;
+let dt = next - previous;
+let p = origin + dir * (0.5 * (previous + next));
+previous = next;
+let pr = length(p);
+let d = oz(pr);
+let e = extinction(d);
+let vb = fO(pr, dot(p, params.sun.xyz) / pr);
+let nG = RAYLEIGH * d.x;
+let nF = MIE_SCATTERING * d.y;
+var ms = vec3f(0.0);
+if (full) { ms = fh(multipleTable, vec2f(hR(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }
+let source = vb * (nG * jv + nF * sn) + (nG + nF) * ms;
+let st = exp(-e * dt);
+let weight = (1.0 - st) / max(e, vec3f(1e-9));
+result.radiance += view * source * weight;
+result.throughput += view * (nG + nF) * weight;
+view *= st;
+}
+if (ground) {
+let p = origin + dir * len;
+let pr = length(p);
+let tC = dot(p, params.sun.xyz) / pr;
+let irradiance = fO(pr, tC) * max(tC, 0.0) + uw;
+result.radiance += view * ALBEDO / PI * irradiance;
+}
+return result;
+}
+fn qk(row: f32) -> f32 {
+let x = row / f32(SV_SIZE.y - 1u) * 2.0 - 1.0;
+return sign(x) * x * x * (PI / 2.0);
+}
+fn ik(e: f32) -> f32 {
+let x = sign(e) * sqrt(abs(e) / (PI / 2.0));
+return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);
+}
+@compute @workgroup_size(8, 8)
+fn transmittance(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= T_SIZE)) { return; }
+let mu = f32(id.x) / f32(T_SIZE.x - 1u) * 2.0 - 1.0;
+let r = R_GROUND + mP(f32(id.y) / f32(T_SIZE.y - 1u));
+if (np(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }
+let len = jm(r, mu);
+var depth = vec3f(0.0);
+for (var i = 0u; i < 48u; i++) {
+let t = (f32(i) + 0.5) / 48.0 * len;
+depth += extinction(oz(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);
+}
+textureStore(output, vec2i(id.xy), vec4f(exp(-depth), 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn multiple(@builtin(global_invocation_id) id: vec3u) {
+if (id.x >= MS_ALTITUDES || id.y > 0u) { return; }
+let r = R_GROUND + mP(f32(id.x) / f32(MS_ALTITUDES - 1u));
+var second = vec3f(0.0);
+var qK = vec3f(0.0);
+for (var i = 0u; i < 64u; i++) {
+let mu = 1.0 - 2.0 * (f32(i) + 0.5) / 64.0;
+let phi = f32(i) * PI * (3.0 - sqrt(5.0));
+let s = sqrt(1.0 - mu * mu);
+let result = vt(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));
+second += result.radiance / 64.0;
+qK += result.throughput / 64.0;
+}
+textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - qK), 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn skyView(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= SV_SIZE)) { return; }
+let e = qk(f32(id.y));
+let phi = f32(id.x) / f32(SV_SIZE.x - 1u) * PI;
+var sky = vec3f(0.0);
+if (params.size.w > 0.0) { sky = textureLoad(irradianceTable, vec2i(0), 0).rgb; }
+let result = vt(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);
+textureStore(output, vec2i(id.xy), vec4f(result.radiance, 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn irradiance(@builtin(global_invocation_id) id: vec3u) {
+if (id.x >= 2u || id.y > 0u) { return; }
+var sky = vec3f(0.0);
+for (var i = 0u; i < 128u; i++) {
+let e = (f32(i) + 0.5) / 128.0 * (PI / 2.0);
+let weight = 2.0 * sin(e) * cos(e) * (PI / 2.0 / 128.0) * (PI / 48.0);
+for (var j = 0u; j < 48u; j++) {
+let phi = (f32(j) + 0.5) / 48.0 * PI;
+sky += fh(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), ik(e))) * weight;
+}
+}
+if (id.x == 0u) { textureStore(output, vec2i(id.xy), vec4f(sky, 1.0)); return; }
+let vb = fO(R_GROUND + CAMERA_ALTITUDE, params.sun.y);
+let xc = vec3f(0.2126, 0.7152, 0.0722);
+let horizontal = dot(sky, xc) + dot(vb, xc) * max(params.sun.y, 0.0);
+let scale = ${ILLUMINANCE} / sqrt(max(horizontal, ${REFERENCE_ILLUMINANCE} * 1e-3) * ${REFERENCE_ILLUMINANCE});
+textureStore(output, vec2i(id.xy), vec4f(vb, scale));
+}
+fn hn(dk: vec2f) -> vec3f {
+let theta = dk.y / params.size.y * PI;
+let phi = dk.x / params.size.x * 2.0 * PI;
+return vec3f(-sin(theta) * cos(phi), cos(theta), -sin(theta) * sin(phi));
+}
+@compute @workgroup_size(8, 8)
+fn map(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= vec2u(params.size.xy))) { return; }
+let dk = vec2f(id.xy) + 0.5;
+let dir = hn(dk);
+let th = abs(atan2(dir.z, dir.x) - params.sun.w);
+let wr = th - floor(th / (2.0 * PI)) * (2.0 * PI);
+let ek = min(wr, 2.0 * PI - wr);
+let e = asin(clamp(dir.y, -1.0, 1.0));
+var radiance = fh(skyTable, vec2f(ek / PI * f32(SV_SIZE.x - 1u), ik(e)));
+let sun = textureLoad(irradianceTable, vec2i(1, 0), 0);
+let radius = params.sunWorld.w;
+let rP = PI / params.size.y;
+if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * rP / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {
+var coverage = 0.0;
+for (var y = 0u; y < 6u; y++) { for (var x = 0u; x < 6u; x++) {
+let d = hn(dk - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);
+let angle = 2.0 * asin(min(length(d - params.sunWorld.xyz) * 0.5, 1.0));
+let t = angle / radius;
+if (t < 1.0) { coverage += 1.0 - 0.6 * (1.0 - sqrt(1.0 - t * t)); }
+} }
+let rO = 2.0 * PI * (1.0 - cos(radius));
+radiance += coverage / 36.0 / (rO * (1.0 - 0.6 / 3.0)) * sun.rgb;
+}
+textureStore(output, vec2i(id.xy), vec4f(radiance * sun.a * params.scale.xyz + params.ambient.xyz, 1.0));
+}
+`;
+//# sourceMappingURL=proceduralSky.compute.js.map